@nocobase/cli 2.1.0-beta.24 → 2.1.0-beta.26

package/dist/commands/config/set.js

@@ -0,0 +1,35 @@
+/**
+ * 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 { assertSupportedCliConfigKey, setCliConfigValue } from '../../lib/cli-config.js';
+export default class ConfigSet extends Command {
+    static summary = 'Set a CLI configuration value';
+    static description = 'Set a supported CLI configuration key. Supported keys: license.pkg-url, docker.network, docker.container-prefix.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> license.pkg-url https://pkg.nocobase.com/',
+        '<%= config.bin %> <%= command.id %> docker.network nocobase',
+        '<%= config.bin %> <%= command.id %> docker.container-prefix nb',
+    ];
+    static args = {
+        key: Args.string({
+            description: 'Configuration key',
+            required: true,
+        }),
+        value: Args.string({
+            description: 'Configuration value',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(ConfigSet);
+        const key = assertSupportedCliConfigKey(args.key);
+        const value = await setCliConfigValue(key, args.value);
+        this.log(`${key}=${value}`);
+    }
+}

package/dist/commands/db/check.js

@@ -7,10 +7,13 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
-import { formatMissingManagedAppEnvMessage } from '../../lib/app-runtime.js';
-import { getEnv } from '../../lib/auth-store.js';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { resolveBuiltinDbConnection } from '../../lib/builtin-db.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;
@@ -18,19 +21,166 @@ function trimValue(value) {
 function resolveRequiredDbField(flagValue, envValue) {
     return trimValue(flagValue) ?? trimValue(envValue);
 }
-function formatMissingFieldsMessage(missing) {
+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(', ')}.`,
-        'Pass `--env <name>` to reuse a saved env, or provide all `--db-*` flags explicitly.',
+        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 envConfig = { ...runtime.env.config };
+    if ((runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb) {
+        const builtinDbConnection = await resolveBuiltinDbConnection(runtime);
+        envConfig.dbHost = builtinDbConnection.dbHost;
+        envConfig.dbPort = builtinDbConnection.dbPort;
+        envConfig.dbDialect = builtinDbConnection.dbDialect;
+    }
+    const dbConfig = resolveDbConfigFromFlags(flags, envConfig);
+    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 the current machine can connect to a database using saved env config or explicit --db-* flags.';
+    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 %> --db-dialect postgres --db-host 127.0.0.1 --db-port 5432 --db-database nocobase --db-user nocobase --db-password secret',
         '<%= 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({
@@ -63,70 +213,26 @@ export default class DbCheck extends Command {
     };
     async run() {
         const { flags } = await this.parse(DbCheck);
-        const envName = flags.env?.trim() || undefined;
-        const env = envName || !flags['db-host'] ? await getEnv(envName) : undefined;
-        if (envName && !env) {
-            this.error(formatMissingManagedAppEnvMessage(envName));
-        }
-        const config = env?.config ?? {};
-        const dbConfig = {
-            builtinDb: false,
-            dbDialect: resolveRequiredDbField(flags['db-dialect'], config.dbDialect),
-            dbHost: resolveRequiredDbField(flags['db-host'], config.dbHost),
-            dbPort: resolveRequiredDbField(flags['db-port'], config.dbPort),
-            dbDatabase: resolveRequiredDbField(flags['db-database'], config.dbDatabase),
-            dbUser: resolveRequiredDbField(flags['db-user'], config.dbUser),
-            dbPassword: flags['db-password'] !== undefined
-                ? String(flags['db-password'] ?? '')
-                : String(config.dbPassword ?? ''),
-        };
-        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) {
-            this.error(formatMissingFieldsMessage(missing));
-        }
-        const portError = validateTcpPort(dbConfig.dbPort);
-        if (portError) {
-            this.error(portError);
-        }
-        const connectionConfig = readExternalDbConnectionConfig(dbConfig);
-        if (!connectionConfig) {
-            this.error('Unsupported or incomplete database settings for connectivity check.');
-        }
-        const address = formatDbCheckAddress(connectionConfig);
-        const validationError = await checkExternalDbConnection(connectionConfig);
+        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: !validationError,
-                env: env?.name,
-                dialect: connectionConfig.dialect,
-                address,
-                error: validationError ?? null,
+                ok: result.ok,
+                env: input.envName,
+                kind: input.kind,
+                dialect: result.dialect,
+                address: result.address,
+                error: result.error,
             }, null, 2));
             return;
         }
-        if (validationError) {
-            this.error(validationError);
+        if (!result.ok) {
+            this.error(result.error ?? 'Database check failed.');
         }
-        this.log(env?.name
-            ? `Database check passed for env "${env.name}" (${connectionConfig.dialect} ${address}).`
-            : `Database check passed (${connectionConfig.dialect} ${address}).`);
+        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/logs.js

@@ -47,7 +47,7 @@ export default class DbLogs extends Command {
         follow: Flags.boolean({
             char: 'f',
             description: 'Keep streaming new log lines',
-            default: true,
+            default: false,
             allowNo: true,
         }),
     };
@@ -62,7 +62,7 @@ export default class DbLogs extends Command {
             this.error(formatUnmanagedDbLogsMessage(runtime));
         }
         const tail = String(flags.tail ?? 100);
-        const follow = flags.follow !== false;
+        const follow = flags.follow === true;
         printInfo(follow
             ? `Showing built-in database logs for "${runtime.envName}" (press Ctrl+C to stop).`
             : `Showing recent built-in database logs for "${runtime.envName}".`);

package/dist/commands/db/shared.js

@@ -6,7 +6,8 @@
  * 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, resolveManagedAppRuntime, } from '../../lib/app-runtime.js';
+import { dockerContainerExists, dockerContainerIsRunning, resolveManagedAppRuntime, } from '../../lib/app-runtime.js';
+import { resolveBuiltinDbConnection } from '../../lib/builtin-db.js';
 function formatAddress(host, port, fallbackHost) {
     const normalizedHost = String(host ?? '').trim() || String(fallbackHost ?? '').trim();
     const normalizedPort = String(port ?? '').trim();
@@ -23,14 +24,14 @@ 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 connection = await resolveBuiltinDbConnection(runtime);
         return {
             kind: 'builtin',
             envName: runtime.envName,
             source,
-            dbDialect,
-            containerName,
-            address: formatAddress(runtime.env.config.dbHost, runtime.env.config.dbPort, containerName),
+            dbDialect: connection.dbDialect,
+            containerName: connection.containerName,
+            address: formatAddress(connection.dbHost, connection.dbPort, connection.containerName),
             appRuntime: runtime,
         };
     }

package/dist/commands/db/start.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, startDockerContainer, } from '../../lib/app-runtime.js';
-import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, startTask, succeedTask } from '../../lib/ui.js';
 import { formatUnmanagedDbMessage, resolveDbRuntime } from './shared.js';
 function formatDbStartFailure(envName, message) {
     if (/does not exist/i.test(message)) {
@@ -52,6 +52,7 @@ export default class DbStart extends Command {
         if (runtime.kind !== 'builtin') {
             this.error(formatUnmanagedDbMessage('start', runtime));
         }
+        announceTargetEnv(runtime.envName);
         startTask(`Starting the built-in database for "${runtime.envName}"...`);
         try {
             const state = await startDockerContainer(runtime.containerName, {

package/dist/commands/db/stop.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, stopDockerContainer, } from '../../lib/app-runtime.js';
-import { failTask, startTask, succeedTask } from '../../lib/ui.js';
+import { announceTargetEnv, failTask, startTask, succeedTask } from '../../lib/ui.js';
 import { formatUnmanagedDbMessage, resolveDbRuntime } from './shared.js';
 function formatDbStopFailure(envName, message) {
     if (/does not exist/i.test(message)) {
@@ -52,6 +52,7 @@ export default class DbStop extends Command {
         if (runtime.kind !== 'builtin') {
             this.error(formatUnmanagedDbMessage('stop', runtime));
         }
+        announceTargetEnv(runtime.envName);
         startTask(`Stopping the built-in database for "${runtime.envName}"...`);
         try {
             const state = await stopDockerContainer(runtime.containerName, {

package/dist/commands/env/info.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { resolveBuiltinDbConnection } from '../../lib/builtin-db.js';
 import { renderTable } from '../../lib/ui.js';
 import { appRootPath, dbStatus, runtimeStatus, storagePath } from './shared.js';
 function normalizeJsonValue(value) {
@@ -85,6 +86,9 @@ export default class EnvInfo extends Command {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
         }
         const auth = runtime.env.auth;
+        const builtinDbConnection = (runtime.kind === 'local' || runtime.kind === 'docker') && runtime.env.config.builtinDb
+            ? await resolveBuiltinDbConnection(runtime)
+            : undefined;
         const appGroup = {
             appRootPath: appRootPath(runtime),
             storagePath: storagePath(runtime),
@@ -101,8 +105,8 @@ export default class EnvInfo extends Command {
             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,
+            dbHost: builtinDbConnection?.dbHost ?? runtime.env.config.dbHost,
+            dbPort: builtinDbConnection?.dbPort ?? runtime.env.config.dbPort,
             dbDatabase: runtime.env.config.dbDatabase,
             dbUser: runtime.env.config.dbUser,
             dbPassword: maskSecret(runtime.env.config.dbPassword, showSecrets),

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/install.js

@@ -17,12 +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";
@@ -812,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') {
@@ -837,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) {
@@ -1183,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 = {};
@@ -1229,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
@@ -1520,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,
@@ -1567,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,
@@ -1615,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,
@@ -2076,8 +2086,11 @@ 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) {
@@ -2095,7 +2108,8 @@ export default class Install extends Command {
         if (Boolean(dbResults.builtinDb)) {
             builtinDbPlan = await this.startBuiltinDb({
                 envName,
-                workspaceName,
+                dockerNetworkName,
+                dockerContainerPrefix,
                 appResults,
                 downloadResults,
                 dbResults,
@@ -2119,7 +2133,8 @@ export default class Install extends Command {
                 });
                 dockerAppPlan = await this.installDockerApp({
                     envName,
-                    workspaceName,
+                    dockerNetworkName,
+                    dockerContainerPrefix,
                     appResults,
                     downloadResults,
                     dbResults,