@nocobase/cli 2.1.0-alpha.26 → 2.1.0-alpha.27

package/dist/commands/db/check.js

@@ -0,0 +1,230 @@
+/**
+ * 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 { checkExternalDbConnection, formatDbCheckAddress, readExternalDbConnectionConfig, } from "../../lib/db-connection-check.js";
+import { commandOutput } from '../../lib/run-npm.js';
+import { validateTcpPort } from "../../lib/prompt-validators.js";
+const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
+const DEFAULT_DOCKER_VERSION = 'alpha';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function resolveRequiredDbField(flagValue, envValue) {
+    return trimValue(flagValue) ?? trimValue(envValue);
+}
+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 formatMissingFieldsMessage(missing, hasEnv) {
+    return [
+        'Missing database settings for connectivity check.',
+        `Required: ${missing.join(', ')}.`,
+        hasEnv
+            ? 'Pass `--env <name>` to reuse a saved env, or provide the missing `--db-*` flags explicitly.'
+            : 'Provide all required `--db-*` flags explicitly, or pass `--env <name>` to reuse a saved env.',
+    ].join('\n');
+}
+function resolveDbConfigFromFlags(flags, envConfig) {
+    return {
+        builtinDb: false,
+        dbDialect: resolveRequiredDbField(flags['db-dialect'], envConfig?.dbDialect),
+        dbHost: resolveRequiredDbField(flags['db-host'], envConfig?.dbHost),
+        dbPort: resolveRequiredDbField(flags['db-port'], envConfig?.dbPort),
+        dbDatabase: resolveRequiredDbField(flags['db-database'], envConfig?.dbDatabase),
+        dbUser: resolveRequiredDbField(flags['db-user'], envConfig?.dbUser),
+        dbPassword: flags['db-password'] !== undefined
+            ? String(flags['db-password'] ?? '')
+            : envConfig?.dbPassword !== undefined
+                ? String(envConfig.dbPassword ?? '')
+                : undefined,
+    };
+}
+function validateDbConfigOrThrow(command, dbConfig, hasEnv) {
+    const missing = [];
+    if (!dbConfig.dbDialect) {
+        missing.push('--db-dialect');
+    }
+    if (!dbConfig.dbHost) {
+        missing.push('--db-host');
+    }
+    if (!dbConfig.dbPort) {
+        missing.push('--db-port');
+    }
+    if (!dbConfig.dbDatabase) {
+        missing.push('--db-database');
+    }
+    if (!dbConfig.dbUser) {
+        missing.push('--db-user');
+    }
+    if (!dbConfig.dbPassword) {
+        missing.push('--db-password');
+    }
+    if (missing.length > 0) {
+        command.error(formatMissingFieldsMessage(missing, hasEnv));
+    }
+    const portError = validateTcpPort(dbConfig.dbPort);
+    if (portError) {
+        command.error(portError);
+    }
+}
+async function resolveDbCheckInput(command, flags) {
+    const envName = flags.env?.trim() || undefined;
+    if (!envName) {
+        const dbConfig = resolveDbConfigFromFlags(flags);
+        validateDbConfigOrThrow(command, dbConfig, false);
+        return {
+            dbConfig,
+        };
+    }
+    const runtime = await resolveManagedAppRuntime(envName);
+    if (!runtime) {
+        command.error(formatMissingManagedAppEnvMessage(envName));
+    }
+    const dbConfig = resolveDbConfigFromFlags(flags, runtime.env.config);
+    validateDbConfigOrThrow(command, dbConfig, true);
+    return {
+        envName: runtime.envName,
+        kind: runtime.kind,
+        runtime: runtime,
+        dbConfig,
+    };
+}
+function buildConnectionConfigOrThrow(command, dbConfig) {
+    const connectionConfig = readExternalDbConnectionConfig(dbConfig);
+    if (!connectionConfig) {
+        command.error('Unsupported or incomplete database settings for connectivity check.');
+    }
+    return connectionConfig;
+}
+async function runExplicitDbCheck(command, dbConfig) {
+    const connectionConfig = buildConnectionConfigOrThrow(command, dbConfig);
+    const address = formatDbCheckAddress(connectionConfig);
+    const validationError = await checkExternalDbConnection(connectionConfig);
+    return {
+        ok: !validationError,
+        dialect: connectionConfig.dialect,
+        address,
+        error: validationError ?? null,
+    };
+}
+async function runDockerDbCheck(command, runtime, dbConfig) {
+    const connectionConfig = buildConnectionConfigOrThrow(command, dbConfig);
+    const config = runtime.env.config ?? {};
+    const imageRef = `${trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY}:${trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION}`;
+    const args = [
+        'run',
+        '--rm',
+        '--network',
+        runtime.dockerNetworkName || runtime.workspaceName,
+    ];
+    const dockerPlatform = normalizeDockerPlatform(config.dockerPlatform);
+    if (dockerPlatform) {
+        args.push('--platform', dockerPlatform);
+    }
+    args.push('--entrypoint', 'nb', imageRef, 'db', 'check', '--db-dialect', connectionConfig.dialect, '--db-host', connectionConfig.host, '--db-port', String(connectionConfig.port), '--db-database', connectionConfig.database, '--db-user', connectionConfig.user, '--db-password', connectionConfig.password, '--json');
+    const output = await commandOutput('docker', args, {
+        errorName: 'docker run',
+    });
+    let payload;
+    try {
+        payload = JSON.parse(output);
+    }
+    catch {
+        command.error(`Failed to parse database check response from Docker: ${output}`);
+    }
+    const ok = Boolean(payload.ok);
+    const dialect = trimValue(payload.dialect) || connectionConfig.dialect;
+    const address = trimValue(payload.address) || formatDbCheckAddress(connectionConfig);
+    const error = trimValue(payload.error) || null;
+    return {
+        ok,
+        dialect,
+        address,
+        error,
+    };
+}
+async function runDbCheckForRuntime(command, runtime, dbConfig) {
+    if (runtime.kind === 'docker') {
+        return await runDockerDbCheck(command, runtime, dbConfig);
+    }
+    if (runtime.kind === 'local') {
+        return await runExplicitDbCheck(command, dbConfig);
+    }
+    command.error(`Env "${runtime.envName}" does not support automatic database connectivity checks.`);
+}
+export default class DbCheck extends Command {
+    static description = 'Check whether a database is reachable using the selected env settings or explicit `--db-*` flags.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --db-password new-secret --json',
+        '<%= config.bin %> <%= command.id %> --db-dialect postgres --db-host 127.0.0.1 --db-port 5432 --db-database nocobase --db-user nocobase --db-password secret',
+    ];
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            description: 'CLI env name to read saved database settings from. Defaults to the current env when omitted.',
+        }),
+        'db-dialect': Flags.string({
+            description: 'Database dialect: postgres, kingbase, mysql, or mariadb.',
+            options: ['postgres', 'kingbase', 'mysql', 'mariadb'],
+        }),
+        'db-host': Flags.string({
+            description: 'Database host name or IP address.',
+        }),
+        'db-port': Flags.string({
+            description: 'Database TCP port.',
+        }),
+        'db-database': Flags.string({
+            description: 'Database name.',
+        }),
+        'db-user': Flags.string({
+            description: 'Database username.',
+        }),
+        'db-password': Flags.string({
+            description: 'Database password.',
+        }),
+        json: Flags.boolean({
+            description: 'Output the check result as JSON.',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(DbCheck);
+        const input = await resolveDbCheckInput(this, flags);
+        const result = input.runtime
+            ? await runDbCheckForRuntime(this, input.runtime, input.dbConfig)
+            : await runExplicitDbCheck(this, input.dbConfig);
+        if (flags.json) {
+            this.log(JSON.stringify({
+                ok: result.ok,
+                env: input.envName,
+                kind: input.kind,
+                dialect: result.dialect,
+                address: result.address,
+                error: result.error,
+            }, null, 2));
+            return;
+        }
+        if (!result.ok) {
+            this.error(result.error ?? 'Database check failed.');
+        }
+        this.log(input.envName
+            ? `Database check passed for env "${input.envName}" (${result.dialect} ${result.address}).`
+            : `Database check passed (${result.dialect} ${result.address}).`);
+    }
+}

package/dist/commands/db/shared.js

@@ -23,7 +23,7 @@ export async function resolveDbRuntime(envName) {
     const source = runtime.kind === 'http' || runtime.kind === 'ssh' ? runtime.kind : runtime.source;
     const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
     if ((runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb) {
-        const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.workspaceName);
+        const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
         return {
             kind: 'builtin',
             envName: runtime.envName,

package/dist/commands/env/shared.js

@@ -141,7 +141,7 @@ export async function dbStatus(runtime) {
         return '-';
     }
     const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
-    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.workspaceName);
+    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
     return await dockerStatus(containerName);
 }
 export async function runtimeStatus(runtime) {

package/dist/commands/init.js

@@ -303,7 +303,6 @@ Prompt modes:
         }),
         'skip-skills': Flags.boolean({
             description: 'Skip installing or updating NocoBase AI coding skills during init',
-            hidden: true,
             default: false,
         }),
         'ui-host': Flags.string({

package/dist/commands/install.js

@@ -17,11 +17,14 @@ import { exit } from 'node:process';
 import { runPromptCatalog, } from "../lib/prompt-catalog.js";
 import { applyCliLocale, localeText, resolveCliLocale, translateCli, } from "../lib/cli-locale.js";
 import { resolveConfiguredEnvPath, resolveDefaultConfigScope, resolveEnvRoot, resolveEnvRelativePath, } from '../lib/cli-home.js';
+import { defaultDockerContainerPrefix, defaultDockerNetworkName, } from '../lib/app-runtime.js';
+import { resolveDockerContainerPrefix, resolveDockerNetworkName, } from '../lib/cli-config.js';
 import { findAvailableTcpPort, validateAvailableTcpPort, validateTcpPort, validateEnvKey, } from "../lib/prompt-validators.js";
+import { validateExternalDbConfig } from "../lib/db-connection-check.js";
 import { formatMissingManagedAppEnvMessage } from '../lib/app-runtime.js';
 import { run, runNocoBaseCommand } from '../lib/run-npm.js';
 import { startTask, stopTask, updateTask } from '../lib/ui.js';
-import { ensureWorkspaceName, getEnv, loadAuthConfig, upsertEnv } from '../lib/auth-store.js';
+import { getEnv, upsertEnv } from '../lib/auth-store.js';
 import { buildStoredEnvConfig } from '../lib/env-config.js';
 import Download, { defaultDockerRegistryForLang, } from './download.js';
 import EnvAdd from "./env/add.js";
@@ -180,6 +183,16 @@ function validateBuiltinDbEnabled(value, values) {
     }
     return translateCli('commands.install.validation.builtinDbUnsupported', { dialect });
 }
+async function validateExternalDbPromptField(value, values) {
+    const builtinDb = values.builtinDb === undefined ? true : Boolean(values.builtinDb);
+    if (builtinDb) {
+        return undefined;
+    }
+    if (typeof value === 'string' && value.trim() === '') {
+        return undefined;
+    }
+    return await validateExternalDbConfig(values);
+}
 function defaultInstallAppRootPath(envName) {
     const name = String(envName ?? DEFAULT_INSTALL_ENV_NAME).trim() || DEFAULT_INSTALL_ENV_NAME;
     return `./${name}/source/`;
@@ -447,6 +460,7 @@ export default class Install extends Command {
             initialValue: (values) => defaultDbHostForBuiltinDb(values),
             yesInitialValue: DEFAULT_INSTALL_BUILTIN_DB_HOST,
             required: true,
+            validate: validateExternalDbPromptField,
             hidden: (values) => Boolean(values.builtinDb),
         },
         dbPort: {
@@ -464,6 +478,7 @@ export default class Install extends Command {
             message: installText('prompts.dbDatabase.message'),
             initialValue: (values) => defaultDbDatabaseForDialect(values.dbDialect),
             required: true,
+            validate: validateExternalDbPromptField,
         },
         dbUser: {
             type: 'text',
@@ -471,6 +486,7 @@ export default class Install extends Command {
             initialValue: DEFAULT_INSTALL_DB_USER,
             yesInitialValue: DEFAULT_INSTALL_DB_USER,
             required: true,
+            validate: validateExternalDbPromptField,
         },
         dbPassword: {
             type: 'password',
@@ -478,6 +494,7 @@ export default class Install extends Command {
             initialValue: DEFAULT_INSTALL_DB_PASSWORD,
             yesInitialValue: DEFAULT_INSTALL_DB_PASSWORD,
             required: true,
+            validate: validateExternalDbPromptField,
         },
     };
     static rootUserPrompts = {
@@ -741,6 +758,9 @@ export default class Install extends Command {
         const builtinDb = values.builtinDb === undefined ? true : Boolean(values.builtinDb);
         const source = String(values.source ?? '').trim();
         if (!builtinDb || source === 'docker') {
+            if (!builtinDb) {
+                return await validateExternalDbConfig({ ...values, dbPort: value });
+            }
             return undefined;
         }
         return await Install.validateResumeAwareTcpPort(value, values, 'db');
@@ -765,6 +785,23 @@ export default class Install extends Command {
         });
         return reusesManagedPort ? undefined : portError;
     }
+    static async ensureExternalDbReadyForInstall(dbResults) {
+        const builtinDb = dbResults.builtinDb === undefined ? true : Boolean(dbResults.builtinDb);
+        if (builtinDb) {
+            return;
+        }
+        const dialect = String(dbResults.dbDialect ?? 'postgres').trim() || 'postgres';
+        const host = String(dbResults.dbHost ?? '').trim();
+        const port = String(dbResults.dbPort ?? '').trim();
+        const database = String(dbResults.dbDatabase ?? '').trim();
+        const address = host && port ? `${host}:${port}` : host || port || '(unknown address)';
+        const target = database ? `${address}/${database}` : address;
+        p.log.step(`Checking external ${dialect} database: ${target}`);
+        const validationError = await validateExternalDbConfig(dbResults);
+        if (validationError) {
+            throw new Error(validationError);
+        }
+    }
     static async readResumePortValidationContext(values) {
         if (!Boolean(values.resume)) {
             return undefined;
@@ -777,24 +814,23 @@ export default class Install extends Command {
         const builtinDb = values.builtinDb === undefined ? undefined : Boolean(values.builtinDb);
         const dbDialect = Install.toOptionalPromptString(values.dbDialect);
         const appRootPath = Install.toOptionalPromptString(values.appRootPath);
-        const workspaceName = Install.toOptionalPromptString(values.workspaceName)
-            ?? await Install.resolveResumeWorkspaceName(envName);
+        const dockerNetworkName = await Install.resolveResumeDockerNetworkName();
+        const dockerContainerPrefix = await Install.resolveResumeDockerContainerPrefix();
         return {
             envName,
-            ...(workspaceName ? { workspaceName } : {}),
+            ...(dockerNetworkName ? { dockerNetworkName } : {}),
+            ...(dockerContainerPrefix ? { dockerContainerPrefix } : {}),
             ...(source ? { source } : {}),
             ...(builtinDb !== undefined ? { builtinDb } : {}),
             ...(dbDialect ? { dbDialect } : {}),
             ...(appRootPath ? { appRootPath } : {}),
         };
     }
-    static async resolveResumeWorkspaceName(envName) {
-        if (!envName) {
-            return undefined;
-        }
-        const config = await loadAuthConfig({ scope: resolveDefaultConfigScope() });
-        const stored = String(config.name ?? '').trim();
-        return stored || Install.defaultWorkspaceName();
+    static async resolveResumeDockerNetworkName() {
+        return await resolveDockerNetworkName({ scope: resolveDefaultConfigScope() });
+    }
+    static async resolveResumeDockerContainerPrefix() {
+        return await resolveDockerContainerPrefix({ scope: resolveDefaultConfigScope() });
     }
     static async isResumeManagedPortReuse(params) {
         if (params.target === 'app') {
@@ -802,13 +838,13 @@ export default class Install extends Command {
                 && params.context.appRootPath) {
                 return await Install.isLocalPm2ProcessUsingPort(params.context.appRootPath, params.port);
             }
-            const containerName = Install.buildDockerAppContainerName(params.context.envName, params.context.workspaceName);
+            const containerName = Install.buildDockerAppContainerName(params.context.envName, params.context.dockerContainerPrefix);
             return await Install.isDockerContainerPublishingPort(containerName, params.port);
         }
         if (!params.context.builtinDb || params.context.source === 'docker') {
             return false;
         }
-        const containerName = Install.buildBuiltinDbContainerName(params.context.envName, params.context.dbDialect ?? 'postgres', params.context.workspaceName);
+        const containerName = Install.buildBuiltinDbContainerName(params.context.envName, params.context.dbDialect ?? 'postgres', params.context.dockerContainerPrefix);
         return await Install.isDockerContainerPublishingPort(containerName, params.port);
     }
     static async isDockerContainerPublishingPort(containerName, port) {
@@ -1148,27 +1184,33 @@ export default class Install extends Command {
             .replace(/^-+|-+$/g, '');
         return normalized || 'nocobase';
     }
-    static defaultWorkspaceName() {
-        return Install.sanitizeDockerResourceName(`nb-${path.basename(resolveEnvRoot(resolveDefaultConfigScope()))}`);
+    static defaultDockerNetworkName() {
+        return Install.sanitizeDockerResourceName(defaultDockerNetworkName());
     }
-    static buildBuiltinDbResourcePrefix(envName, workspaceName) {
-        void envName;
-        const storedName = String(workspaceName ?? '').trim();
+    static defaultDockerContainerPrefix() {
+        return Install.sanitizeDockerResourceName(defaultDockerContainerPrefix(resolveEnvRoot(resolveDefaultConfigScope())));
+    }
+    static buildBuiltinDbContainerPrefix(containerPrefix) {
+        const storedName = String(containerPrefix ?? '').trim();
         return storedName
             ? Install.sanitizeDockerResourceName(storedName)
-            : Install.defaultWorkspaceName();
+            : Install.defaultDockerContainerPrefix();
     }
-    static async ensureWorkspaceName() {
-        return await ensureWorkspaceName(Install.defaultWorkspaceName(), { scope: resolveDefaultConfigScope() });
+    static buildManagedDockerNetworkName(networkName) {
+        const storedName = String(networkName ?? '').trim();
+        return storedName
+            ? Install.sanitizeDockerResourceName(storedName)
+            : Install.defaultDockerNetworkName();
     }
-    static buildBuiltinDbNetworkName(envName, workspaceName) {
-        return Install.buildBuiltinDbResourcePrefix(envName, workspaceName);
+    static buildBuiltinDbNetworkName(envName, networkName) {
+        void envName;
+        return Install.buildManagedDockerNetworkName(networkName);
     }
-    static buildBuiltinDbContainerName(envName, dbDialect, workspaceName) {
-        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbResourcePrefix(envName, workspaceName)}-${envName}-${dbDialect}`);
+    static buildBuiltinDbContainerName(envName, dbDialect, containerPrefix) {
+        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbContainerPrefix(containerPrefix)}-${envName}-${dbDialect}`);
     }
-    static buildDockerAppContainerName(envName, workspaceName) {
-        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbResourcePrefix(envName, workspaceName)}-${envName}-app`);
+    static buildDockerAppContainerName(envName, containerPrefix) {
+        return Install.sanitizeDockerResourceName(`${Install.buildBuiltinDbContainerPrefix(containerPrefix)}-${envName}-app`);
     }
     static buildInitAppEnvVars(params) {
         const out = {};
@@ -1194,8 +1236,8 @@ export default class Install extends Command {
         const dbPort = String(params.dbPort ?? defaultDbPortForDialect(dbDialect)).trim()
             || defaultDbPortForDialect(dbDialect);
         const defaultDbDatabase = defaultDbDatabaseForDialect(dbDialect);
-        const networkName = Install.buildBuiltinDbNetworkName(params.envName, params.workspaceName);
-        const containerName = Install.buildBuiltinDbContainerName(params.envName, dbDialect, params.workspaceName);
+        const networkName = Install.buildBuiltinDbNetworkName(params.envName, params.dockerNetworkName ?? params.workspaceName);
+        const containerName = Install.buildBuiltinDbContainerName(params.envName, dbDialect, params.dockerContainerPrefix ?? params.workspaceName);
         const dbHostInput = String(params.dbHost ?? '').trim();
         const dbHost = Install.shouldPublishBuiltinDbPort(params.source)
             ? (dbHostInput
@@ -1485,6 +1527,8 @@ export default class Install extends Command {
         const plan = Install.buildBuiltinDbPlan({
             envName: params.envName,
             workspaceName: params.workspaceName,
+            dockerNetworkName: params.dockerNetworkName,
+            dockerContainerPrefix: params.dockerContainerPrefix,
             storagePath,
             source: params.downloadResults.source,
             dbDialect: params.dbResults.dbDialect,
@@ -1532,7 +1576,7 @@ export default class Install extends Command {
         const dbPassword = String(params.dbResults.dbPassword ?? DEFAULT_INSTALL_DB_PASSWORD) || DEFAULT_INSTALL_DB_PASSWORD;
         const appKey = crypto.randomBytes(32).toString('hex');
         const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-        const containerName = Install.buildDockerAppContainerName(params.envName, params.workspaceName);
+        const containerName = Install.buildDockerAppContainerName(params.envName, params.dockerContainerPrefix ?? params.workspaceName);
         const initEnvVars = Install.buildInitAppEnvVars({
             appResults: params.appResults,
             rootResults: params.rootResults,
@@ -1580,11 +1624,12 @@ export default class Install extends Command {
     }
     async installDockerApp(params) {
         const networkName = params.builtinDbPlan?.networkName
-            ?? Install.buildBuiltinDbNetworkName(params.envName, params.workspaceName);
+            ?? Install.buildBuiltinDbNetworkName(params.envName, params.dockerNetworkName ?? params.workspaceName);
         await this.ensureDockerNetwork(networkName);
         const plan = Install.buildDockerAppPlan({
             envName: params.envName,
             workspaceName: params.workspaceName,
+            dockerContainerPrefix: params.dockerContainerPrefix,
             appResults: params.appResults,
             downloadResults: params.downloadResults,
             dbResults: params.dbResults,
@@ -2041,9 +2086,13 @@ export default class Install extends Command {
         const source = String(downloadResultsValue(downloadResults, 'source') ?? '').trim();
         const usesDockerResources = Boolean(dbResults.builtinDb)
             || (Boolean(appResults.fetchSource) && source === 'docker');
-        const workspaceName = usesDockerResources
-            ? await Install.ensureWorkspaceName()
+        const dockerNetworkName = usesDockerResources
+            ? await resolveDockerNetworkName({ scope: resolveDefaultConfigScope() })
+            : undefined;
+        const dockerContainerPrefix = usesDockerResources
+            ? await resolveDockerContainerPrefix({ scope: resolveDefaultConfigScope() })
             : undefined;
+        await Install.ensureExternalDbReadyForInstall(dbResults);
         if (!parsed.resume) {
             await this.saveInstalledEnv({
                 envName,
@@ -2053,12 +2102,14 @@ export default class Install extends Command {
                 rootResults,
                 envAddResults,
             });
+            p.log.info(`Saved install config for env "${envName}"`);
         }
         let builtinDbPlan;
         if (Boolean(dbResults.builtinDb)) {
             builtinDbPlan = await this.startBuiltinDb({
                 envName,
-                workspaceName,
+                dockerNetworkName,
+                dockerContainerPrefix,
                 appResults,
                 downloadResults,
                 dbResults,
@@ -2082,7 +2133,8 @@ export default class Install extends Command {
                 });
                 dockerAppPlan = await this.installDockerApp({
                     envName,
-                    workspaceName,
+                    dockerNetworkName,
+                    dockerContainerPrefix,
                     appResults,
                     downloadResults,
                     dbResults,