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

package/dist/lib/app-managed-resources.js

@@ -0,0 +1,268 @@
+/**
+ * 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 { mkdir, readdir } from 'node:fs/promises';
+import { dockerContainerExists, startDockerContainer } from './app-runtime.js';
+import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+import { commandSucceeds, run } from './run-npm.js';
+import Install from '../commands/install.js';
+const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
+const DEFAULT_DOCKER_VERSION = 'alpha';
+const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
+function commandStdio(verbose) {
+    return verbose ? 'inherit' : 'ignore';
+}
+async function ensureDockerNetwork(networkName) {
+    if (await commandSucceeds('docker', ['network', 'inspect', networkName])) {
+        return;
+    }
+    await run('docker', ['network', 'create', networkName], {
+        errorName: 'docker network create',
+    });
+}
+function localSourceLabel(source) {
+    return source === 'git' ? 'Git checkout' : 'npm app';
+}
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function normalizeDockerPlatform(value) {
+    const text = trimValue(value);
+    if (!text || text === 'auto') {
+        return undefined;
+    }
+    if (text === 'linux/amd64' || text === 'linux/arm64') {
+        return text;
+    }
+    return undefined;
+}
+function formatBuiltinDbFailure(envName, message) {
+    return [
+        `Couldn't restore the built-in database for "${envName}".`,
+        'Check the saved database settings, local storage path, and Docker runtime, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function formatLocalSourceRestoreFailure(envName, source, message) {
+    const sourceLabel = source === 'git' ? 'the saved Git checkout' : 'the saved npm app';
+    return [
+        `Couldn't restore NocoBase files for "${envName}".`,
+        `The CLI was not able to download ${sourceLabel} before starting the app again.`,
+        'Check the saved source settings for this env, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+function formatSavedDockerSettingsIncomplete(envName, missing) {
+    return [
+        `Can't start NocoBase for "${envName}" yet.`,
+        `The saved Docker settings for this env are incomplete. Missing: ${missing.join(', ')}.`,
+        'Re-run `nb init` or `nb env add` to refresh this env config, then try again.',
+    ].join('\n');
+}
+function formatDockerAppRecreateFailure(envName, message) {
+    return [
+        `Couldn't start NocoBase for "${envName}".`,
+        'The CLI was not able to recreate the saved Docker app container successfully.',
+        'Check the saved Docker image, container settings, and database connection, then try again.',
+        `Details: ${message}`,
+    ].join('\n');
+}
+async function localProjectHasFiles(projectRoot) {
+    try {
+        const entries = await readdir(projectRoot);
+        return entries.length > 0;
+    }
+    catch (_error) {
+        return false;
+    }
+}
+export function buildSavedDockerRunArgs(runtime) {
+    const config = runtime.env.config ?? {};
+    const configuredStoragePath = trimValue(config.storagePath);
+    const storagePath = configuredStoragePath
+        ? trimValue(resolveConfiguredEnvPath(configuredStoragePath))
+        : '';
+    const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
+        ? ''
+        : trimValue(runtime.env.appPort);
+    const appKey = trimValue(config.appKey);
+    const timeZone = trimValue(config.timezone) || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+    const builtinDbConnection = config.builtinDb ? deriveBuiltinDbConnection(runtime) : undefined;
+    const dbDialect = builtinDbConnection?.dbDialect || trimValue(config.dbDialect);
+    const dbHost = builtinDbConnection?.dbHost || trimValue(config.dbHost);
+    const dbPort = builtinDbConnection?.dbPort || trimValue(config.dbPort);
+    const dbDatabase = trimValue(config.dbDatabase);
+    const dbUser = trimValue(config.dbUser);
+    const dbPassword = trimValue(config.dbPassword);
+    const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
+    const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
+    const imageRef = `${dockerRegistry}:${version}`;
+    const missing = [];
+    if (!storagePath) {
+        missing.push('storagePath');
+    }
+    if (!appKey) {
+        missing.push('appKey');
+    }
+    if (!dbDialect) {
+        missing.push('dbDialect');
+    }
+    if (!dbHost) {
+        missing.push('dbHost');
+    }
+    if (!dbPort) {
+        missing.push('dbPort');
+    }
+    if (!dbDatabase) {
+        missing.push('dbDatabase');
+    }
+    if (!dbUser) {
+        missing.push('dbUser');
+    }
+    if (!dbPassword) {
+        missing.push('dbPassword');
+    }
+    if (missing.length > 0) {
+        throw new Error(formatSavedDockerSettingsIncomplete(runtime.envName, missing));
+    }
+    const args = [
+        'run',
+        '-d',
+        '--name',
+        runtime.containerName,
+        '--restart',
+        'always',
+        '--network',
+        runtime.workspaceName,
+    ];
+    const dockerPlatform = normalizeDockerPlatform(config.dockerPlatform);
+    if (dockerPlatform) {
+        args.push('--platform', dockerPlatform);
+    }
+    if (appPort) {
+        args.push('-p', `${appPort}:80`);
+    }
+    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`, imageRef);
+    return {
+        appPort: appPort || undefined,
+        storagePath,
+        imageRef,
+        args,
+    };
+}
+export async function recreateSavedDockerApp(runtime, options) {
+    const plan = buildSavedDockerRunArgs(runtime);
+    try {
+        await ensureDockerNetwork(runtime.workspaceName);
+        await mkdir(plan.storagePath, { recursive: true });
+        await run('docker', plan.args, {
+            errorName: 'docker run',
+            stdio: commandStdio(options?.verbose),
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes(`Can't start NocoBase for "${runtime.envName}" yet.`)
+            || message.includes(`Couldn't start NocoBase for "${runtime.envName}".`)) {
+            throw error instanceof Error ? error : new Error(message);
+        }
+        throw new Error(formatDockerAppRecreateFailure(runtime.envName, message));
+    }
+}
+export async function ensureBuiltinDbReady(runtime, options) {
+    const config = runtime.env.config ?? {};
+    if (!config.builtinDb) {
+        return;
+    }
+    const builtinDbConnection = await resolveBuiltinDbConnection(runtime);
+    const plan = Install.buildBuiltinDbPlan({
+        envName: runtime.envName,
+        workspaceName: runtime.workspaceName,
+        dockerContainerPrefix: runtime.dockerContainerPrefix,
+        storagePath: config.storagePath,
+        source: runtime.source,
+        dbDialect: builtinDbConnection.dbDialect,
+        dbHost: builtinDbConnection.dbHost,
+        dbPort: builtinDbConnection.dbPort,
+        dbDatabase: config.dbDatabase,
+        dbUser: config.dbUser,
+        dbPassword: config.dbPassword,
+        builtinDbImage: config.builtinDbImage,
+    });
+    options?.onStartTask?.(`Restoring the built-in ${plan.dbDialect} database for "${runtime.envName}"...`);
+    try {
+        await ensureDockerNetwork(plan.networkName);
+        if (await dockerContainerExists(plan.containerName)) {
+            const state = await startDockerContainer(plan.containerName, {
+                stdio: commandStdio(options?.verbose),
+            });
+            options?.onSucceedTask?.(state === 'already-running'
+                ? `The built-in ${plan.dbDialect} database is already running for "${runtime.envName}" at ${plan.dbHost}:${plan.dbPort}.`
+                : `The built-in ${plan.dbDialect} database is running for "${runtime.envName}" at ${plan.dbHost}:${plan.dbPort}.`);
+            return;
+        }
+        await mkdir(plan.dataDir, { recursive: true });
+        await run('docker', plan.args, {
+            errorName: 'docker run',
+            stdio: commandStdio(options?.verbose),
+        });
+        options?.onSucceedTask?.(`The built-in ${plan.dbDialect} database is running for "${runtime.envName}" at ${plan.dbHost}:${plan.dbPort}.`);
+    }
+    catch (error) {
+        options?.onFailTask?.(`Failed to restore the built-in database for "${runtime.envName}".`);
+        throw new Error(formatBuiltinDbFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
+    }
+}
+export function buildSavedLocalDownloadArgv(runtime, options) {
+    const config = runtime.env.config ?? {};
+    const argv = ['-y', '--no-intro'];
+    if (options?.verbose) {
+        argv.push('--verbose');
+    }
+    argv.push('--source', runtime.source, '--replace', '--output-dir', runtime.projectRoot);
+    const version = String(config.downloadVersion ?? '').trim();
+    const gitUrl = String(config.gitUrl ?? '').trim();
+    const npmRegistry = String(config.npmRegistry ?? '').trim();
+    if (version) {
+        argv.push('--version', version);
+    }
+    if (gitUrl) {
+        argv.push('--git-url', gitUrl);
+    }
+    if (npmRegistry) {
+        argv.push('--npm-registry', npmRegistry);
+    }
+    if (config.devDependencies === true) {
+        argv.push('--dev-dependencies');
+    }
+    if (config.build === false) {
+        argv.push('--no-build');
+    }
+    if (config.buildDts === true) {
+        argv.push('--build-dts');
+    }
+    return argv;
+}
+export async function ensureSavedLocalSource(runtime, runCommand, options) {
+    if (await localProjectHasFiles(runtime.projectRoot)) {
+        return;
+    }
+    const sourceLabel = localSourceLabel(runtime.source);
+    options?.onStartTask?.(`Restoring the saved ${sourceLabel} for "${runtime.envName}"...`);
+    try {
+        await runCommand('source:download', buildSavedLocalDownloadArgv(runtime, {
+            verbose: options?.verbose,
+        }));
+        options?.onSucceedTask?.(`NocoBase files are ready for "${runtime.envName}".`);
+    }
+    catch (error) {
+        options?.onFailTask?.(`Failed to restore NocoBase files for "${runtime.envName}".`);
+        throw new Error(formatLocalSourceRestoreFailure(runtime.envName, runtime.source, error instanceof Error ? error.message : String(error)));
+    }
+}

package/dist/lib/app-runtime.js

@@ -0,0 +1,171 @@
+/**
+ * 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 { resolveEnvKind } from './auth-store.js';
+import { getEnv, loadAuthConfig } from './auth-store.js';
+import { DEFAULT_DOCKER_CONTAINER_PREFIX, DEFAULT_DOCKER_NETWORK, getEffectiveCliConfigValue, } from './cli-config.js';
+import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
+import { buildRuntimeEnvVars } from './runtime-env-vars.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 defaultDockerContainerPrefix(cwd = process.cwd()) {
+    const configured = String(DEFAULT_DOCKER_CONTAINER_PREFIX ?? '').trim();
+    if (configured) {
+        return sanitizeDockerResourceName(configured);
+    }
+    return defaultWorkspaceName(cwd);
+}
+export function defaultDockerNetworkName() {
+    return sanitizeDockerResourceName(DEFAULT_DOCKER_NETWORK);
+}
+export function buildDockerAppContainerName(envName, containerPrefix) {
+    const prefix = containerPrefix?.trim() || defaultDockerContainerPrefix();
+    return sanitizeDockerResourceName(`${prefix}-${envName}-app`);
+}
+export function buildDockerDbContainerName(envName, dbDialect, containerPrefix) {
+    const prefix = containerPrefix?.trim() || defaultDockerContainerPrefix();
+    const dialect = dbDialect.trim() || 'postgres';
+    return sanitizeDockerResourceName(`${prefix}-${envName}-${dialect}`);
+}
+function normalizeEnvSource(env) {
+    const source = String(env.config.source ?? '').trim();
+    if (source === 'docker' || source === 'npm' || source === 'git') {
+        return source;
+    }
+    const kind = resolveEnvKind(env.config);
+    if (kind === 'local') {
+        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 dockerNetworkName = sanitizeDockerResourceName(getEffectiveCliConfigValue(config, 'docker.network') || defaultDockerNetworkName());
+    const dockerContainerPrefix = sanitizeDockerResourceName(getEffectiveCliConfigValue(config, 'docker.container-prefix') || defaultDockerContainerPrefix());
+    const kind = env.kind ?? resolveEnvKind(env.config);
+    if (kind === 'docker') {
+        return {
+            kind: 'docker',
+            env,
+            envName: resolvedName,
+            source: 'docker',
+            dockerNetworkName,
+            dockerContainerPrefix,
+            workspaceName: dockerNetworkName,
+            containerName: buildDockerAppContainerName(resolvedName, dockerContainerPrefix),
+        };
+    }
+    if (kind === 'local') {
+        return {
+            kind: 'local',
+            env,
+            envName: resolvedName,
+            source: source === 'git' ? 'git' : source === 'npm' ? 'npm' : 'local',
+            projectRoot: env.appRootPath,
+            dockerNetworkName,
+            dockerContainerPrefix,
+            workspaceName: dockerNetworkName,
+        };
+    }
+    if (kind === 'ssh') {
+        return {
+            kind: 'ssh',
+            env,
+            envName: resolvedName,
+            source,
+        };
+    }
+    return {
+        kind: 'http',
+        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) {
+    const envVars = await buildRuntimeEnvVars(runtime);
+    await runNocoBaseCommand(args, {
+        cwd: runtime.projectRoot,
+        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',
+    });
+}