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

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/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,

package/dist/lib/app-runtime.js

@@ -9,7 +9,9 @@
 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
@@ -23,14 +25,24 @@ function sanitizeDockerResourceName(value) {
 export function defaultWorkspaceName(cwd = process.cwd()) {
     return sanitizeDockerResourceName(`nb-${path.basename(cwd)}`);
 }
-export function buildDockerAppContainerName(envName, workspaceName) {
-    const workspace = workspaceName?.trim() || defaultWorkspaceName();
-    return sanitizeDockerResourceName(`${workspace}-${envName}-app`);
+export function 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, workspaceName) {
-    const workspace = workspaceName?.trim() || defaultWorkspaceName();
+export function buildDockerDbContainerName(envName, dbDialect, containerPrefix) {
+    const prefix = containerPrefix?.trim() || defaultDockerContainerPrefix();
     const dialect = dbDialect.trim() || 'postgres';
-    return sanitizeDockerResourceName(`${workspace}-${envName}-${dialect}`);
+    return sanitizeDockerResourceName(`${prefix}-${envName}-${dialect}`);
 }
 function normalizeEnvSource(env) {
     const source = String(env.config.source ?? '').trim();
@@ -51,7 +63,8 @@ export async function resolveManagedAppRuntime(envName) {
     }
     const resolvedName = env.name || envName?.trim() || config.currentEnv || 'default';
     const source = normalizeEnvSource(env);
-    const workspaceName = config.name?.trim() || defaultWorkspaceName();
+    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 {
@@ -59,8 +72,10 @@ export async function resolveManagedAppRuntime(envName) {
             env,
             envName: resolvedName,
             source: 'docker',
-            workspaceName,
-            containerName: buildDockerAppContainerName(resolvedName, workspaceName),
+            dockerNetworkName,
+            dockerContainerPrefix,
+            workspaceName: dockerNetworkName,
+            containerName: buildDockerAppContainerName(resolvedName, dockerContainerPrefix),
         };
     }
     if (kind === 'local') {
@@ -70,7 +85,9 @@ export async function resolveManagedAppRuntime(envName) {
             envName: resolvedName,
             source: source === 'git' ? 'git' : source === 'npm' ? 'npm' : 'local',
             projectRoot: env.appRootPath,
-            workspaceName,
+            dockerNetworkName,
+            dockerContainerPrefix,
+            workspaceName: dockerNetworkName,
         };
     }
     if (kind === 'ssh') {
@@ -99,9 +116,10 @@ export function formatMissingManagedAppEnvMessage(envName) {
     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: runtime.env.envVars,
+        env: envVars,
         stdio: options?.stdio,
     });
 }

package/dist/lib/auth-store.js

@@ -8,7 +8,7 @@
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { NB_CLI_ROOT_ENV, resolveCliHomeDir, resolveConfiguredEnvPath, resolveDefaultConfigScope, resolveEnvRelativePath, } from './cli-home.js';
+import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath, } from './cli-home.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
     if (kind === 'remote') {
@@ -68,8 +68,22 @@ function normalizeEnvConfigEntry(entry) {
     };
 }
 function normalizeAuthConfig(config) {
+    const settings = config.settings ?? {};
     return {
         name: config.name || config.dockerResourcePrefix,
+        settings: {
+            ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
+            ...(settings.docker?.network || settings.docker?.containerPrefix
+                ? {
+                    docker: {
+                        ...(settings.docker?.network ? { network: normalizeOptionalString(settings.docker.network) } : {}),
+                        ...(settings.docker?.containerPrefix
+                            ? { containerPrefix: normalizeOptionalString(settings.docker.containerPrefix) }
+                            : {}),
+                    },
+                }
+                : {}),
+        },
         currentEnv: config.currentEnv || 'default',
         envs: Object.fromEntries(Object.entries(config.envs || {}).map(([envName, entry]) => [envName, normalizeEnvConfigEntry(entry) ?? {}])),
     };
@@ -83,48 +97,21 @@ function createDefaultConfig() {
         envs: {},
     };
 }
-function hasConfiguredEnvs(config) {
-    return Object.keys(config.envs).length > 0;
-}
-function shouldFallbackToLegacyProjectScope(options = {}) {
-    const requestedScope = options.scope ?? resolveDefaultConfigScope();
-    if (requestedScope !== 'global') {
-        return false;
-    }
-    return !process.env[NB_CLI_ROOT_ENV];
-}
-async function loadExactAuthConfig(options = {}) {
+async function readStoredAuthConfig(filePath) {
     try {
-        const content = await fs.readFile(getConfigFile(options), 'utf8');
+        const content = await fs.readFile(filePath, 'utf8');
         const parsed = JSON.parse(content);
         return normalizeAuthConfig(parsed);
     }
     catch (_error) {
-        return createDefaultConfig();
+        return undefined;
     }
 }
-async function resolveEnvStorageScope(envName, options = {}) {
-    const requestedScope = options.scope ?? resolveDefaultConfigScope();
-    if (requestedScope !== 'global') {
-        return { ...options, scope: requestedScope };
-    }
-    const globalConfig = await loadExactAuthConfig({ scope: 'global' });
-    if (globalConfig.envs[envName]) {
-        return { ...options, scope: 'global' };
-    }
-    const projectConfig = await loadExactAuthConfig({ scope: 'project' });
-    if (projectConfig.envs[envName]) {
-        return { ...options, scope: 'project' };
-    }
-    return { ...options, scope: 'global' };
+export async function loadExactAuthConfig(options = {}) {
+    return (await readStoredAuthConfig(getConfigFile(options))) ?? createDefaultConfig();
 }
 export async function loadAuthConfig(options = {}) {
-    const config = await loadExactAuthConfig(options);
-    if (!shouldFallbackToLegacyProjectScope(options) || hasConfiguredEnvs(config)) {
-        return config;
-    }
-    const legacyProjectConfig = await loadExactAuthConfig({ scope: 'project' });
-    return hasConfiguredEnvs(legacyProjectConfig) ? legacyProjectConfig : config;
+    return await loadExactAuthConfig(options);
 }
 export async function saveAuthConfig(config, options = {}) {
     const filePath = getConfigFile(options);
@@ -143,24 +130,12 @@ export async function getCurrentEnvName(options = {}) {
     return config.currentEnv || 'default';
 }
 export async function setCurrentEnv(envName, options = {}) {
-    const writeOptions = await resolveEnvStorageScope(envName, options);
-    const config = await loadExactAuthConfig(writeOptions);
+    const config = await loadExactAuthConfig(options);
     if (!config.envs[envName]) {
         throw new Error(`Env "${envName}" is not configured`);
     }
     config.currentEnv = envName;
-    await saveAuthConfig(config, writeOptions);
-}
-export async function ensureWorkspaceName(defaultName, options = {}) {
-    const config = await loadExactAuthConfig(options);
-    const existing = config.name?.trim();
-    if (existing) {
-        return existing;
-    }
-    const next = defaultName.trim();
-    config.name = next;
     await saveAuthConfig(config, options);
-    return next;
 }
 export class Env {
     config;
@@ -220,8 +195,13 @@ export class Env {
         put('APP_KEY', this.config.appKey);
         put('TZ', this.config.timezone);
         put('DB_DIALECT', this.config.dbDialect);
-        put('DB_HOST', this.config.dbHost);
-        put('DB_PORT', this.config.dbPort);
+        if (!this.config.builtinDb) {
+            put('DB_HOST', this.config.dbHost);
+            put('DB_PORT', this.config.dbPort);
+        }
+        else if (String(this.config.source ?? '').trim() !== 'docker') {
+            put('DB_PORT', this.config.dbPort);
+        }
         put('DB_DATABASE', this.config.dbDatabase);
         put('DB_USER', this.config.dbUser);
         put('DB_PASSWORD', this.config.dbPassword);
@@ -234,16 +214,7 @@ export async function getEnv(envName, options = {}) {
     const resolved = envName?.trim() || config.currentEnv || 'default';
     const envConfig = config.envs[resolved];
     if (!envConfig) {
-        if (!shouldFallbackToLegacyProjectScope(loadOptions)) {
-            return undefined;
-        }
-        const legacyProjectConfig = await loadExactAuthConfig({ scope: 'project' });
-        const legacyResolved = envName?.trim() || legacyProjectConfig.currentEnv || 'default';
-        const legacyEnvConfig = legacyProjectConfig.envs[legacyResolved];
-        if (!legacyEnvConfig) {
-            return undefined;
-        }
-        return new Env({ ...(normalizeEnvConfigEntry(legacyEnvConfig) ?? {}), name: legacyResolved });
+        return undefined;
     }
     return new Env({ ...(normalizeEnvConfigEntry(envConfig) ?? {}), name: resolved });
 }
@@ -269,12 +240,11 @@ function areAuthConfigsEquivalent(left, right) {
     return false;
 }
 async function writeEnv(envName, updater, options = {}) {
-    const writeOptions = await resolveEnvStorageScope(envName, options);
-    const config = await loadExactAuthConfig(writeOptions);
+    const config = await loadExactAuthConfig(options);
     const previous = config.envs[envName];
     config.envs[envName] = updater(previous);
     config.currentEnv = envName;
-    await saveAuthConfig(config, writeOptions);
+    await saveAuthConfig(config, options);
 }
 export async function upsertEnv(envName, config, options = {}) {
     await writeEnv(envName, (previous) => {
@@ -330,19 +300,17 @@ export async function setEnvOauthSession(envName, auth, options = {}) {
     }), options);
 }
 export async function setEnvRuntime(envName, runtime, options = {}) {
-    const writeOptions = await resolveEnvStorageScope(envName, options);
-    const config = await loadExactAuthConfig(writeOptions);
+    const config = await loadExactAuthConfig(options);
     const current = config.envs[envName] ?? {};
     config.envs[envName] = {
         ...current,
         runtime,
     };
     config.currentEnv = envName;
-    await saveAuthConfig(config, writeOptions);
+    await saveAuthConfig(config, options);
 }
 export async function removeEnv(envName, options = {}) {
-    const writeOptions = await resolveEnvStorageScope(envName, options);
-    const config = await loadExactAuthConfig(writeOptions);
+    const config = await loadExactAuthConfig(options);
     if (!config.envs[envName]) {
         throw new Error(`Env "${envName}" is not configured`);
     }
@@ -351,7 +319,7 @@ export async function removeEnv(envName, options = {}) {
         const nextEnv = Object.keys(config.envs).sort()[0];
         config.currentEnv = nextEnv ?? 'default';
     }
-    await saveAuthConfig(config, writeOptions);
+    await saveAuthConfig(config, options);
     return {
         removed: envName,
         currentEnv: config.currentEnv || 'default',

package/dist/lib/build-config.js

@@ -1,3 +1,11 @@
+/**
+ * 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 { promises as fs } from 'node:fs';
 export async function loadBuildConfig(filePath) {
     try {

package/dist/lib/builtin-db.js

@@ -0,0 +1,86 @@
+/**
+ * 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 { buildDockerDbContainerName } from './app-runtime.js';
+import { commandOutput } from './run-npm.js';
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+export function defaultBuiltinDbPortForDialect(value) {
+    const dialect = trimValue(value) || 'postgres';
+    switch (dialect) {
+        case 'mysql':
+        case 'mariadb':
+            return '3306';
+        case 'kingbase':
+            return '54321';
+        case 'postgres':
+        default:
+            return '5432';
+    }
+}
+export function resolveBuiltinDbContainerName(runtime, dbDialect) {
+    const dialect = trimValue(dbDialect ?? runtime.env.config.dbDialect) || 'postgres';
+    return buildDockerDbContainerName(runtime.envName, dialect, runtime.dockerContainerPrefix || runtime.workspaceName);
+}
+export function deriveBuiltinDbConnection(runtime, overrides = {}) {
+    const dbDialect = trimValue(overrides.dbDialect ?? runtime.env.config.dbDialect) || 'postgres';
+    const containerName = resolveBuiltinDbContainerName(runtime, dbDialect);
+    const networkName = trimValue(runtime.dockerNetworkName || runtime.workspaceName) || undefined;
+    if (runtime.source === 'docker') {
+        return {
+            builtinDb: true,
+            dbDialect,
+            dbHost: containerName,
+            dbPort: defaultBuiltinDbPortForDialect(dbDialect),
+            containerName,
+            networkName,
+        };
+    }
+    const dbPort = trimValue(overrides.dbPort ?? runtime.env.config.dbPort) || defaultBuiltinDbPortForDialect(dbDialect);
+    return {
+        builtinDb: true,
+        dbDialect,
+        dbHost: '127.0.0.1',
+        dbPort,
+        containerName,
+        networkName,
+    };
+}
+export async function resolveBuiltinDbConnection(runtime) {
+    const derived = deriveBuiltinDbConnection(runtime);
+    if (runtime.source === 'docker') {
+        return derived;
+    }
+    const mappedPort = await inspectBuiltinDbPublishedPort(derived.containerName, derived.dbDialect);
+    if (mappedPort) {
+        return {
+            ...derived,
+            dbPort: mappedPort,
+        };
+    }
+    return derived;
+}
+async function inspectBuiltinDbPublishedPort(containerName, dbDialect) {
+    const containerPort = defaultBuiltinDbPortForDialect(dbDialect);
+    try {
+        const output = await commandOutput('docker', [
+            'inspect',
+            '--format',
+            `{{with index .NetworkSettings.Ports "${containerPort}/tcp"}}{{(index . 0).HostPort}}{{end}}`,
+            containerName,
+        ], {
+            errorName: 'docker inspect',
+        });
+        const hostPort = trimValue(output);
+        return hostPort || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}