@nocobase/cli 2.1.0-beta.23 → 2.1.0-beta.25

package/dist/commands/license/shared.js

@@ -0,0 +1,414 @@
+/**
+ * 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 { Flags } from '@oclif/core';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getEnvAsync, getInstanceIdAsync, keyDecrypt } from '@nocobase/license-kit';
+import _ from 'lodash';
+import { checkExternalDbConnection, readExternalDbConnectionConfig, } from "../../lib/db-connection-check.js";
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { buildRuntimeEnvVars } from '../../lib/runtime-env-vars.js';
+import { resolveLicensePkgUrlFromConfig } from '../../lib/cli-config.js';
+import { commandOutput } from '../../lib/run-npm.js';
+import { appUrl } from '../env/shared.js';
+export const licenseEnvFlag = Flags.string({
+    char: 'e',
+    description: 'CLI env name (from `nb env` / `nb init`). Defaults to the current env when omitted',
+});
+export const licenseJsonFlag = Flags.boolean({
+    description: 'Output the result as JSON',
+    default: false,
+});
+const DEFAULT_LICENSE_PKG_URL = 'https://pkg.nocobase.com/';
+const DEFAULT_DOCKER_REGISTRY = 'nocobase/nocobase';
+const DEFAULT_DOCKER_VERSION = 'alpha';
+export const licensePkgUrlFlag = Flags.string({
+    description: 'Commercial package service base URL',
+    hidden: true,
+});
+export async function requireLicenseRuntime(envName) {
+    const runtime = await resolveManagedAppRuntime(envName);
+    if (!runtime) {
+        throw new Error(formatMissingManagedAppEnvMessage(envName));
+    }
+    return runtime;
+}
+export function resolveLicenseDir(runtime) {
+    return path.resolve(runtime.env.storagePath, '.license');
+}
+export function resolveInstanceIdFile(runtime) {
+    return path.resolve(resolveLicenseDir(runtime), 'instance-id');
+}
+export function resolveLicenseKeyFile(runtime) {
+    return path.resolve(resolveLicenseDir(runtime), 'license-key');
+}
+export async function readSavedInstanceId(runtime) {
+    try {
+        const value = await readFile(resolveInstanceIdFile(runtime), 'utf8');
+        const normalized = value.trim();
+        return normalized || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+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 resolveDockerLicenseImageRef(runtime) {
+    const config = runtime.env.config ?? {};
+    return `${trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY}:${trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION}`;
+}
+function buildDockerLicenseDbFlagArgs(envVars) {
+    return [
+        '--db-dialect',
+        String(envVars.DB_DIALECT ?? ''),
+        '--db-host',
+        String(envVars.DB_HOST ?? ''),
+        '--db-port',
+        String(envVars.DB_PORT ?? ''),
+        '--db-database',
+        String(envVars.DB_DATABASE ?? ''),
+        '--db-user',
+        String(envVars.DB_USER ?? ''),
+        '--db-password',
+        String(envVars.DB_PASSWORD ?? ''),
+    ];
+}
+async function runDockerLicenseJsonCommand(runtime, commandArgs) {
+    const args = [
+        'run',
+        '--rm',
+        '--network',
+        runtime.dockerNetworkName || runtime.workspaceName,
+    ];
+    const dockerPlatform = normalizeDockerPlatform(runtime.env.config?.dockerPlatform);
+    if (dockerPlatform) {
+        args.push('--platform', dockerPlatform);
+    }
+    args.push('--entrypoint', 'nb', resolveDockerLicenseImageRef(runtime), ...commandArgs, '--json');
+    const output = await commandOutput('docker', args, {
+        errorName: 'docker run',
+    });
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        throw new Error(`Failed to parse Docker license command response: ${output}`);
+    }
+}
+function buildLicenseDbConfigFromEnvVars(envVars) {
+    return {
+        builtinDb: false,
+        dbDialect: trimValue(envVars.DB_DIALECT),
+        dbHost: trimValue(envVars.DB_HOST),
+        dbPort: trimValue(envVars.DB_PORT),
+        dbDatabase: trimValue(envVars.DB_DATABASE),
+        dbUser: trimValue(envVars.DB_USER),
+        dbPassword: envVars.DB_PASSWORD,
+    };
+}
+export async function validateLicenseDbConnectionFromEnvVars(envVars) {
+    const connectionConfig = readExternalDbConnectionConfig(buildLicenseDbConfigFromEnvVars(envVars));
+    if (!connectionConfig) {
+        throw new Error('Unsupported or incomplete database settings for instance ID generation.');
+    }
+    const validationError = await checkExternalDbConnection(connectionConfig);
+    if (validationError) {
+        throw new Error(validationError);
+    }
+}
+export async function withLicenseEnvVars(nextEnv, task) {
+    const previous = {};
+    for (const [key, value] of Object.entries(nextEnv)) {
+        previous[key] = process.env[key];
+        process.env[key] = value;
+    }
+    try {
+        return await task();
+    }
+    finally {
+        for (const key of Object.keys(nextEnv)) {
+            const value = previous[key];
+            if (value === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = value;
+            }
+        }
+    }
+}
+async function withLicenseEnv(runtime, task) {
+    return await withLicenseEnvVars(await buildRuntimeEnvVars(runtime), task);
+}
+export async function getCurrentLicenseEnv(runtime) {
+    if (runtime.kind === 'docker') {
+        const envVars = await buildRuntimeEnvVars(runtime);
+        const payload = await runDockerLicenseJsonCommand(runtime, [
+            'license',
+            'env',
+            ...buildDockerLicenseDbFlagArgs(envVars),
+        ]);
+        return payload?.env;
+    }
+    return await withLicenseEnv(runtime, async () => await getEnvAsync());
+}
+export async function generateInstanceIdFromEnvVars(envVars) {
+    const instanceId = String(await withLicenseEnvVars(envVars, async () => await getInstanceIdAsync())).trim();
+    if (!instanceId) {
+        throw new Error('Generated instance ID is empty.');
+    }
+    return instanceId;
+}
+export async function generateValidatedInstanceIdFromEnvVars(envVars) {
+    await validateLicenseDbConnectionFromEnvVars(envVars);
+    return await generateInstanceIdFromEnvVars(envVars);
+}
+async function generateInstanceIdForDockerRuntime(runtime) {
+    const envVars = await buildRuntimeEnvVars(runtime);
+    const payload = await runDockerLicenseJsonCommand(runtime, [
+        'license',
+        'generate-id',
+        ...buildDockerLicenseDbFlagArgs(envVars),
+    ]);
+    const instanceId = trimValue(payload.instanceId);
+    if (!instanceId) {
+        throw new Error('Docker instance ID generation did not return an instance ID.');
+    }
+    return instanceId;
+}
+export async function generateInstanceIdForRuntime(runtime) {
+    if (runtime.kind === 'docker') {
+        return await generateInstanceIdForDockerRuntime(runtime);
+    }
+    if (runtime.kind === 'local') {
+        return await generateValidatedInstanceIdFromEnvVars(await buildRuntimeEnvVars(runtime));
+    }
+    throw new Error(`Env "${runtime.envName}" does not support automatic instance ID generation.`);
+}
+export async function saveInstanceId(runtime, instanceId) {
+    const normalized = String(instanceId ?? '').trim();
+    if (!normalized) {
+        throw new Error('Generated instance ID is empty.');
+    }
+    await mkdir(resolveLicenseDir(runtime), { recursive: true });
+    await writeFile(resolveInstanceIdFile(runtime), `${normalized}\n`);
+    return normalized;
+}
+export async function generateAndSaveInstanceId(runtime) {
+    const instanceId = await generateInstanceIdForRuntime(runtime);
+    return await saveInstanceId(runtime, instanceId);
+}
+export async function ensureInstanceId(runtime, options = {}) {
+    if (!options.force) {
+        const saved = await readSavedInstanceId(runtime);
+        if (saved) {
+            return saved;
+        }
+    }
+    return await generateAndSaveInstanceId(runtime);
+}
+export function parseLicenseKey(key) {
+    try {
+        return JSON.parse(keyDecrypt(key));
+    }
+    catch {
+        throw new Error('invalid');
+    }
+}
+export async function saveLicenseKey(runtime, key) {
+    await mkdir(resolveLicenseDir(runtime), { recursive: true });
+    const filePath = resolveLicenseKeyFile(runtime);
+    await writeFile(filePath, key.trim());
+    return filePath;
+}
+export async function readSavedLicenseKey(runtime) {
+    try {
+        const value = await readFile(resolveLicenseKeyFile(runtime), 'utf8');
+        const normalized = value.trim();
+        return normalized || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function matchSingleDomain(licenseDomain, currentDomain) {
+    let hostname = '';
+    let port = '';
+    try {
+        const url = new URL(currentDomain);
+        hostname = url.hostname;
+        port = url.port ? `:${url.port}` : '';
+    }
+    catch {
+        return false;
+    }
+    const fullDomain = hostname + port;
+    if (!licenseDomain.includes('*')) {
+        return fullDomain === licenseDomain;
+    }
+    const base = licenseDomain.replace('*', '');
+    return fullDomain.endsWith(base);
+}
+export function isDomainMatch(currentDomain, keyData) {
+    if (!keyData?.licenseKey?.domain || !currentDomain) {
+        return false;
+    }
+    const licenseDomains = String(keyData.licenseKey.domain)
+        .split(',')
+        .map((value) => value.trim())
+        .filter(Boolean);
+    return licenseDomains.some((licenseDomain) => matchSingleDomain(licenseDomain, currentDomain));
+}
+export function isDbMatch(env, keyData) {
+    const currentDb = env?.db;
+    const licenseDb = keyData?.instanceData?.db;
+    if (!currentDb || !licenseDb) {
+        return false;
+    }
+    if (currentDb?.id && licenseDb?.id) {
+        return currentDb.id === licenseDb.id;
+    }
+    return _.isEqual(_.omit(currentDb, ['id']), _.omit(licenseDb, ['id']));
+}
+export function isSysMatch(env, keyData) {
+    const instance = keyData?.instanceData;
+    if (!env || !instance) {
+        return false;
+    }
+    const normalize = (item) => ({
+        sys: item?.sys ?? null,
+        osVer: item?.osVer ?? null,
+    });
+    return _.isEqual(normalize(env), normalize(instance));
+}
+export async function getLicenseStatus(keyData) {
+    if (!keyData) {
+        return 'invalid';
+    }
+    if (keyData.licenseKey?.licenseStatus === 'invalid') {
+        return 'invalid';
+    }
+    const domain = String(keyData.service?.domain ?? '').trim();
+    const accessKeyId = String(keyData.accessKeyId ?? '').trim();
+    const accessKeySecret = String(keyData.accessKeySecret ?? '').trim();
+    if (!domain || !accessKeyId || !accessKeySecret) {
+        return 'active';
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch(`${domain.replace(/\/$/, '')}/api/license_keys:getKeyStatus`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(keyData.service?.headers ?? {}),
+            },
+            body: JSON.stringify({
+                access_key_id: accessKeyId,
+                access_key_secret: accessKeySecret,
+            }),
+            signal: controller.signal,
+        });
+        const payload = await response.json();
+        return payload?.data?.status === 'active' ? 'active' : 'invalid';
+    }
+    catch {
+        return 'active';
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function validateLicenseKey(runtime, key) {
+    let keyData;
+    let keyStatus;
+    try {
+        keyData = parseLicenseKey(key);
+    }
+    catch {
+        keyStatus = 'invalid';
+    }
+    const currentEnv = await getCurrentLicenseEnv(runtime);
+    const currentDomain = appUrl(runtime);
+    const dbMatch = isDbMatch(currentEnv, keyData);
+    const sysMatch = isSysMatch(currentEnv, keyData);
+    const envMatch = dbMatch && sysMatch;
+    const domainMatch = isDomainMatch(currentDomain, keyData);
+    const licenseStatus = await getLicenseStatus(keyData);
+    return {
+        current: {
+            env: currentEnv,
+            domain: currentDomain ? new URL(currentDomain).host : '',
+        },
+        keyData,
+        keyStatus,
+        dbMatch,
+        sysMatch,
+        envMatch,
+        domainMatch,
+        licenseStatus,
+    };
+}
+export function redactLicenseKey(value) {
+    const text = String(value ?? '').trim();
+    if (!text) {
+        return '';
+    }
+    if (text.length <= 8) {
+        return '*'.repeat(text.length);
+    }
+    return `${text.slice(0, 4)}...${text.slice(-4)}`;
+}
+export async function resolveLicenseServiceUrl(value) {
+    return (await resolveLicensePkgUrl(value)).replace(/\/+$/, '');
+}
+export async function resolveLicensePkgUrl(value) {
+    const normalized = String(value ?? '').trim() || await resolveLicensePkgUrlFromConfig();
+    return normalized.replace(/\/+$/, '') + '/';
+}
+function shouldRedactOutputKey(key) {
+    return /accesskeyid|accesskeysecret|secret|token|password|authorization/i.test(key);
+}
+function redactOutputValue(value) {
+    const text = String(value ?? '').trim();
+    if (!text) {
+        return '';
+    }
+    if (text.length <= 8) {
+        return '*'.repeat(text.length);
+    }
+    return `${text.slice(0, 2)}***${text.slice(-2)}`;
+}
+export function sanitizeLicenseOutput(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeLicenseOutput(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            shouldRedactOutputKey(key)
+                ? redactOutputValue(String(nestedValue ?? ''))
+                : sanitizeLicenseOutput(nestedValue),
+        ]));
+    }
+    return value;
+}

package/dist/commands/license/status.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, Flags } from '@oclif/core';
+import { ensureInstanceId, licenseEnvFlag, licenseJsonFlag, requireLicenseRuntime } from './shared.js';
+export default class LicenseStatus extends Command {
+    static summary = 'Show commercial license status for the selected env';
+    static description = 'Inspect the selected env and show the current commercial licensing status. Use `--doctor` for extra diagnostic checks once the license backend wiring is implemented.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --doctor',
+        '<%= config.bin %> <%= command.id %> --env app1 --json',
+    ];
+    static flags = {
+        env: licenseEnvFlag,
+        json: licenseJsonFlag,
+        doctor: Flags.boolean({
+            description: 'Run extra diagnostic checks and suggestions',
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(LicenseStatus);
+        const runtime = await requireLicenseRuntime(flags.env);
+        const payload = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            instanceId: await ensureInstanceId(runtime),
+            licensed: false,
+            doctor: Boolean(flags.doctor),
+            implemented: false,
+            message: 'Commercial license status is not implemented yet in the new CLI.',
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(payload, null, 2));
+            return;
+        }
+        this.log(`License status for env "${runtime.envName}": not implemented yet`);
+        if (flags.doctor) {
+            this.log('Diagnostic checks for commercial licensing are not implemented yet in the new CLI.');
+        }
+    }
+}

package/dist/commands/plugin/disable.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { announceTargetEnv } from '../../lib/ui.js';
 export default class PluginDisable extends Command {
     static hidden = false;
     static args = {
@@ -39,6 +40,7 @@ export default class PluginDisable extends Command {
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(flags.env));
         }
+        announceTargetEnv(runtime.envName);
         if (runtime.kind === 'local') {
             try {
                 await runLocalNocoBaseCommand(runtime, ['pm', 'disable', ...packages]);

package/dist/commands/plugin/enable.js

@@ -8,6 +8,7 @@
  */
 import { Args, Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
+import { announceTargetEnv } from '../../lib/ui.js';
 export default class PluginEnable extends Command {
     static hidden = false;
     static args = {
@@ -39,6 +40,7 @@ export default class PluginEnable extends Command {
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(flags.env));
         }
+        announceTargetEnv(runtime.envName);
         if (runtime.kind === 'local') {
             try {
                 await runLocalNocoBaseCommand(runtime, ['pm', 'enable', ...packages]);

package/dist/commands/source/dev.js

@@ -8,7 +8,7 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runLocalNocoBaseCommand, } from '../../lib/app-runtime.js';
-import { printInfo } from '../../lib/ui.js';
+import { announceTargetEnv, printInfo } from '../../lib/ui.js';
 function formatUnsupportedRuntimeMessage(kind, envName) {
     if (kind === 'docker') {
         return [
@@ -110,6 +110,7 @@ export default class SourceDev extends Command {
         if (runtime.kind === 'docker' || runtime.kind === 'http' || runtime.kind === 'ssh') {
             this.error(formatUnsupportedRuntimeMessage(runtime.kind, runtime.envName));
         }
+        announceTargetEnv(runtime.envName);
         const devPort = flags.port
             || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
                 ? String(runtime.env.appPort).trim()

package/dist/lib/api-client.js

@@ -6,7 +6,19 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+/**
+ * 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 { createWriteStream } from 'node:fs';
 import { promises as fs } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
 import { resolveServerRequestTarget } from './env-auth.js';
 import { fetchWithPreservedAuthRedirect } from './http-request.js';
 const CLI_REQUEST_SOURCE_HEADER = 'x-request-source';
@@ -43,6 +55,20 @@ async function parseResponse(response) {
         data,
     };
 }
+async function parseBinaryResponse(response, outputPath) {
+    if (response.ok && response.body) {
+        await fs.mkdir(dirname(outputPath), { recursive: true }).catch(() => undefined);
+        await pipeline(Readable.fromWeb(response.body), createWriteStream(outputPath));
+        return {
+            ok: response.ok,
+            status: response.status,
+            data: {
+                output: outputPath,
+            },
+        };
+    }
+    return parseResponse(response);
+}
 function parseScalarValue(value, type) {
     if (value === undefined) {
         return undefined;
@@ -105,6 +131,9 @@ function parseBodyFieldValue(rawValue, parameter) {
     return parseScalarValue(rawValue, parameter.type);
 }
 export async function parseBody(flags, operation) {
+    if (operation.requestContentType === 'multipart/form-data') {
+        return undefined;
+    }
     const inlineBody = flags.body;
     const bodyFile = flags['body-file'];
     const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
@@ -143,6 +172,39 @@ export async function parseBody(flags, operation) {
     }
     return undefined;
 }
+async function createMultipartBody(flags, operation) {
+    const bodyParameters = operation.parameters.filter((parameter) => parameter.in === 'body');
+    const formData = new FormData();
+    let hasValues = false;
+    for (const parameter of bodyParameters) {
+        const rawValue = flags[parameter.flagName];
+        const hasValue = hasParameterValue(flags, parameter);
+        if (parameter.required && !hasValue) {
+            throw new Error(`Missing required body field --${parameter.flagName}`);
+        }
+        if (!hasValue) {
+            continue;
+        }
+        if (parameter.isFile) {
+            const filePath = String(rawValue);
+            const content = await fs.readFile(filePath);
+            const arrayBuffer = content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength);
+            formData.append(parameter.name, new Blob([arrayBuffer]), basename(filePath));
+            hasValues = true;
+            continue;
+        }
+        const value = parseBodyFieldValue(rawValue, parameter);
+        if (value === undefined) {
+            continue;
+        }
+        formData.append(parameter.name, typeof value === 'object' ? JSON.stringify(value) : String(value));
+        hasValues = true;
+    }
+    if (!hasValues && operation.bodyRequired) {
+        throw new Error('Missing multipart request body.');
+    }
+    return hasValues ? formData : undefined;
+}
 export async function executeApiRequest(options) {
     const { baseUrl, token } = await resolveServerRequestTarget(options);
     const headers = new Headers();
@@ -190,8 +252,10 @@ export async function executeApiRequest(options) {
             continue;
         }
     }
-    const body = await parseBody(options.flags, options.operation);
-    if (body !== undefined) {
+    const body = options.operation.requestContentType === 'multipart/form-data'
+        ? await createMultipartBody(options.flags, options.operation)
+        : await parseBody(options.flags, options.operation);
+    if (body !== undefined && options.operation.requestContentType !== 'multipart/form-data') {
         headers.set('content-type', 'application/json');
     }
     const url = new URL(`${normalizeBaseUrl(baseUrl)}${requestPath}`);
@@ -199,8 +263,15 @@ export async function executeApiRequest(options) {
     const response = await fetchWithPreservedAuthRedirect(url.toString(), {
         method: options.operation.method.toUpperCase(),
         headers,
-        body: body === undefined ? undefined : JSON.stringify(body),
+        body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
     });
+    if (options.operation.responseType === 'binary') {
+        const outputPath = options.flags.output;
+        if (!outputPath) {
+            throw new Error('Missing required output path --output');
+        }
+        return parseBinaryResponse(response, outputPath);
+    }
     return parseResponse(response);
 }
 export async function executeRawApiRequest(options) {

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

@@ -8,6 +8,7 @@
  */
 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';
@@ -92,9 +93,10 @@ export function buildSavedDockerRunArgs(runtime) {
         : trimValue(runtime.env.appPort);
     const appKey = trimValue(config.appKey);
     const timeZone = trimValue(config.timezone) || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
-    const dbDialect = trimValue(config.dbDialect);
-    const dbHost = trimValue(config.dbHost);
-    const dbPort = trimValue(config.dbPort);
+    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);
@@ -178,14 +180,16 @@ export async function ensureBuiltinDbReady(runtime, options) {
     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: config.dbDialect,
-        dbHost: config.dbHost,
-        dbPort: config.dbPort,
+        dbDialect: builtinDbConnection.dbDialect,
+        dbHost: builtinDbConnection.dbHost,
+        dbPort: builtinDbConnection.dbPort,
         dbDatabase: config.dbDatabase,
         dbUser: config.dbUser,
         dbPassword: config.dbPassword,