@nocobase/cli 2.1.0-beta.8 → 2.1.0

package/dist/commands/env/info.js

@@ -0,0 +1,202 @@
+/**
+ * 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, 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 { appPath, appUrl, dbStatus, runtimeStatus, sourcePath, storagePath } from './shared.js';
+const MISSING_FIELD = Symbol('missingField');
+const FORBIDDEN_FIELD_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype']);
+function normalizeJsonValue(value) {
+    if (value === undefined || value === null || value === '') {
+        return '-';
+    }
+    if (typeof value === 'boolean' || typeof value === 'number') {
+        return value;
+    }
+    return String(value);
+}
+function normalizeValue(value) {
+    if (value === undefined || value === null || value === '') {
+        return '-';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    return String(value);
+}
+function maskSecret(value, showSecrets) {
+    const normalized = normalizeValue(value);
+    if (normalized === '-') {
+        return normalized;
+    }
+    return showSecrets ? normalized : '********';
+}
+function createGroupTable(title, values) {
+    const rows = Object.entries(values).map(([field, value]) => [field, normalizeValue(value)]);
+    return `${title}\n${renderTable(['Field', 'Value'], rows)}`;
+}
+function serializeGroup(values) {
+    return Object.fromEntries(Object.entries(values).map(([field, value]) => [field, normalizeJsonValue(value)]));
+}
+function resolveFieldPath(value, path) {
+    const segments = path
+        .split('.')
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return MISSING_FIELD;
+    }
+    let current = value;
+    for (const segment of segments) {
+        if (!current ||
+            typeof current !== 'object' ||
+            FORBIDDEN_FIELD_PATH_SEGMENTS.has(segment) ||
+            !Object.prototype.hasOwnProperty.call(current, segment)) {
+            return MISSING_FIELD;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+export default class EnvInfo extends Command {
+    static hidden = false;
+    static description = 'Show grouped details for the selected NocoBase env, including app, database, API, and auth settings.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> app1',
+        '<%= config.bin %> <%= command.id %> app1 --json',
+        '<%= config.bin %> <%= command.id %> app1 --show-secrets',
+        '<%= config.bin %> <%= command.id %> app1 --field app.url',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name to inspect. Defaults to the current env when omitted',
+            required: false,
+        }),
+    };
+    static flags = {
+        env: Flags.string({
+            char: 'e',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
+        }),
+        json: Flags.boolean({
+            description: 'Output the result as JSON',
+            default: false,
+        }),
+        field: Flags.string({
+            description: 'Return only a single field using dot notation, for example app.url or api.auth.type',
+        }),
+        'show-secrets': Flags.boolean({
+            description: 'Show secret values in plain text',
+            default: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvInfo);
+        const envNameArg = args.name?.trim() || undefined;
+        const envNameFlag = flags.env?.trim() || undefined;
+        if (envNameArg && envNameFlag && envNameArg !== envNameFlag) {
+            this.error(`Environment name was provided both as the argument ("${envNameArg}") and as --env ("${envNameFlag}"). Please use only one.`);
+        }
+        const requestedEnv = envNameArg || envNameFlag;
+        const showSecrets = flags['show-secrets'];
+        const fieldPath = flags.field?.trim() || undefined;
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            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 dbDialect = builtinDbConnection?.dbDialect ?? runtime.env.config.dbDialect;
+        const appGroup = {
+            url: appUrl(runtime),
+            appPath: appPath(runtime),
+            sourcePath: sourcePath(runtime),
+            storagePath: storagePath(runtime),
+            appPort: runtime.env.config.appPort,
+            appStatus: await runtimeStatus(runtime),
+            source: runtime.source,
+            downloadVersion: runtime.env.config.downloadVersion,
+            dockerRegistry: runtime.env.config.dockerRegistry,
+            dockerPlatform: runtime.env.config.dockerPlatform,
+            timezone: runtime.env.config.timezone,
+        };
+        const dbGroup = {
+            databaseStatus: await dbStatus(runtime),
+            builtinDb: runtime.env.config.builtinDb,
+            dbDialect,
+            builtinDbImage: runtime.env.config.builtinDbImage,
+            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),
+            dbTablePrefix: runtime.env.config.dbTablePrefix,
+            dbUnderscored: runtime.env.config.dbUnderscored,
+            ...(dbDialect === 'postgres' ? { dbSchema: runtime.env.config.dbSchema } : {}),
+        };
+        const authGroup = {
+            type: runtime.env.authType ?? auth?.type,
+            sessionType: auth?.type,
+            username: runtime.env.config.authUsername,
+            expiresAt: auth?.type === 'oauth' ? auth.expiresAt : undefined,
+            scope: auth?.type === 'oauth' ? auth.scope : undefined,
+            issuer: auth?.type === 'oauth' ? auth.issuer : undefined,
+            clientId: auth?.type === 'oauth' ? auth.clientId : undefined,
+            resource: auth?.type === 'oauth' ? auth.resource : undefined,
+            accessToken: maskSecret(auth?.accessToken, showSecrets),
+            refreshToken: maskSecret(auth?.type === 'oauth' ? auth.refreshToken : undefined, showSecrets),
+        };
+        const apiGroup = {
+            apiBaseUrl: runtime.env.apiBaseUrl,
+            'auth.type': authGroup.type,
+            'auth.sessionType': authGroup.sessionType,
+            'auth.username': authGroup.username,
+            'auth.expiresAt': authGroup.expiresAt,
+            'auth.scope': authGroup.scope,
+            'auth.issuer': authGroup.issuer,
+            'auth.clientId': authGroup.clientId,
+            'auth.resource': authGroup.resource,
+            'auth.accessToken': authGroup.accessToken,
+            'auth.refreshToken': authGroup.refreshToken,
+        };
+        const output = {
+            ok: true,
+            env: runtime.envName,
+            kind: runtime.kind,
+            app: serializeGroup(appGroup),
+            db: serializeGroup(dbGroup),
+            api: {
+                apiBaseUrl: normalizeJsonValue(runtime.env.apiBaseUrl),
+                auth: serializeGroup(authGroup),
+            },
+        };
+        if (fieldPath) {
+            const selected = resolveFieldPath(output, fieldPath);
+            if (selected === MISSING_FIELD) {
+                this.error(`Unknown field "${fieldPath}". Use dot notation like app.url, db.databaseStatus, or api.auth.type.`);
+            }
+            if (flags.json) {
+                this.log(JSON.stringify(selected, null, 2));
+                return;
+            }
+            this.log(typeof selected === 'object' ? JSON.stringify(selected, null, 2) : String(selected));
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        this.log([createGroupTable('App', appGroup), createGroupTable('DB', dbGroup), createGroupTable('API', apiGroup)].join('\n\n'));
+    }
+}

package/dist/commands/env/list.js

@@ -0,0 +1,43 @@
+/**
+ * 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 } from '@oclif/core';
+import { getCurrentEnvName, listEnvs, resolveConfiguredAuthType } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { translateCli } from '../../lib/cli-locale.js';
+import { renderTable } from '../../lib/ui.js';
+import { resolveApiBaseUrl } from './shared.js';
+export default class EnvList extends Command {
+    static summary = 'List configured environments';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    async run() {
+        await this.parse(EnvList);
+        const scope = resolveDefaultConfigScope();
+        const { envs } = await listEnvs({ scope });
+        const currentEnv = await getCurrentEnvName({ scope });
+        const names = Object.keys(envs).sort();
+        if (!names.length) {
+            this.log(translateCli('commands.env.messages.noEnvsConfigured'));
+            this.log(translateCli('commands.env.messages.noEnvsConfiguredHelp'));
+            return;
+        }
+        const rows = [];
+        for (const name of names) {
+            const env = envs[name];
+            rows.push([
+                name === currentEnv ? '*' : '',
+                name,
+                env.kind ?? '-',
+                resolveApiBaseUrl(env),
+                resolveConfiguredAuthType(env) ?? env.auth?.type ?? '',
+                env.runtime?.version ?? '',
+            ]);
+        }
+        this.log(renderTable(['Current', 'Name', 'Kind', 'API Base URL', 'Auth', 'Runtime'], rows));
+    }
+}

package/dist/commands/env/remove.js

@@ -0,0 +1,174 @@
+/**
+ * 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, Flags } from '@oclif/core';
+import { resolveManagedAppRuntime } from '../../lib/app-runtime.js';
+import { getCurrentEnvName, loadAuthConfig, removeEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { confirm, input } from "../../lib/inquirer.js";
+import { isInteractiveTerminal, printInfo, printVerbose, setVerboseMode } from '../../lib/ui.js';
+function formatRemoveForceRequiredMessage(envName, purge) {
+    if (purge) {
+        return [
+            `Refusing to purge env "${envName}" without confirmation in non-interactive mode.`,
+            'Re-run with `--purge --force` to continue.',
+        ].join('\n');
+    }
+    return [
+        `Refusing to remove env "${envName}" without confirmation in non-interactive mode.`,
+        'Re-run with `--force` to continue.',
+    ].join('\n');
+}
+function buildRemovePrompt(runtime, options) {
+    const subject = options.isCurrent ? `current env "${runtime.envName}"` : `env "${runtime.envName}"`;
+    if (options.purge) {
+        const lines = [`Purge ${subject}?`];
+        if (runtime.kind === 'local' || runtime.kind === 'docker') {
+            lines.push('This removes CLI-managed local runtime resources for this env on this machine.');
+            lines.push('Storage data will be removed, and downloaded local app files will be removed when applicable.');
+            lines.push('External database services are not managed by the CLI and will be left untouched.');
+        }
+        else {
+            lines.push('This env has no CLI-managed local runtime resources on this machine.');
+            lines.push('Only the saved CLI env config will be removed. External services are not touched.');
+        }
+        lines.push(`Type "${runtime.envName}" to confirm:`);
+        return lines.join('\n');
+    }
+    const lines = [`Remove ${subject}?`];
+    if (runtime.kind === 'local' || runtime.kind === 'docker') {
+        lines.push('NocoBase and any CLI-managed built-in database for this env will be stopped on this machine.');
+        lines.push('The saved CLI env config will then be removed. Storage data and local app files will be kept.');
+    }
+    else {
+        lines.push('Only the saved CLI env config will be removed.');
+    }
+    return lines.join('\n');
+}
+async function confirmEnvRemoval(runtime, options) {
+    if (!isInteractiveTerminal()) {
+        if (options.force) {
+            return true;
+        }
+        throw new Error(formatRemoveForceRequiredMessage(runtime.envName, options.purge));
+    }
+    if (options.force) {
+        return true;
+    }
+    if (options.purge) {
+        try {
+            await input({
+                message: buildRemovePrompt(runtime, options),
+                required: true,
+                validate: (value) => (value.trim() === runtime.envName ? true : `Type "${runtime.envName}" to confirm.`),
+                placeholder: runtime.envName,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        return await confirm({
+            message: buildRemovePrompt(runtime, options),
+            default: false,
+        });
+    }
+    catch {
+        return false;
+    }
+}
+export default class EnvRemove extends Command {
+    static summary = 'Remove a configured environment';
+    static description = 'Remove a configured env. Local and Docker envs stop CLI-managed runtime resources on this machine first; pass `--purge` to also delete managed local resources, storage data, and downloaded app files when applicable.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> staging',
+        '<%= config.bin %> <%= command.id %> staging --force',
+        '<%= config.bin %> <%= command.id %> staging --purge --force',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            hidden: true,
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Skip confirmation for the selected remove mode',
+            default: false,
+        }),
+        purge: Flags.boolean({
+            description: 'Also remove CLI-managed local runtime resources, storage data, and downloaded app files when applicable. For remote API envs, only the saved CLI env config will be removed.',
+            default: false,
+        }),
+        verbose: Flags.boolean({
+            description: 'Show detailed progress output',
+            default: false,
+        }),
+    };
+    static args = {
+        name: Args.string({
+            description: 'Configured environment name to remove',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(EnvRemove);
+        setVerboseMode(flags.verbose);
+        const scope = resolveDefaultConfigScope();
+        const config = await loadAuthConfig({ scope });
+        if (!config.envs[args.name]) {
+            this.error(`Env "${args.name}" is not configured`);
+        }
+        const currentEnv = await getCurrentEnvName({ scope });
+        const runtime = await resolveManagedAppRuntime(args.name);
+        if (!runtime) {
+            this.error(`Env "${args.name}" is not configured`);
+        }
+        const skipConfirmation = flags.yes || flags.force;
+        let confirmed = false;
+        try {
+            confirmed = await confirmEnvRemoval(runtime, {
+                force: skipConfirmation,
+                isCurrent: args.name === currentEnv,
+                purge: flags.purge,
+            });
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : String(error));
+        }
+        if (!confirmed) {
+            return;
+        }
+        const runCommand = this.config.runCommand.bind(this.config);
+        const verboseArgv = flags.verbose ? ['--verbose'] : [];
+        if (flags.purge) {
+            if (runtime.kind === 'local' || runtime.kind === 'docker') {
+                await runCommand('app:destroy', ['--env', runtime.envName, '--force', ...verboseArgv]);
+                return;
+            }
+            printInfo(`No local CLI-managed resources were found for "${runtime.envName}". Removing the saved CLI env config only.`);
+        }
+        else if (runtime.kind === 'local' || runtime.kind === 'docker') {
+            printVerbose(`Stopping CLI-managed runtime resources for "${runtime.envName}" before removing the env config.`);
+            await runCommand('app:stop', ['--env', runtime.envName, '--with-db', '--yes', ...verboseArgv]);
+        }
+        printVerbose(`Removing env "${args.name}"`);
+        const result = await removeEnv(args.name, { scope });
+        if (result.hasEnvs) {
+            if (args.name === currentEnv) {
+                this.log(`Removed env "${result.removed}". Switched current env to "${await getCurrentEnvName({ scope })}".`);
+                return;
+            }
+            this.log(`Removed env "${result.removed}".`);
+            return;
+        }
+        this.log(`Removed env "${result.removed}". No envs configured.`);
+    }
+}

package/dist/commands/env/shared.js

@@ -0,0 +1,204 @@
+/**
+ * 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, dockerContainerExists, dockerContainerIsRunning, } from '../../lib/app-runtime.js';
+import { executeRawApiRequest } from '../../lib/api-client.js';
+import { buildLocalAppUrl } from '../../lib/app-public-path.js';
+export function resolveApiBaseUrl(config) {
+    return String(config.apiBaseUrl ?? config.baseUrl ?? config.apibaseUrl ?? '').trim();
+}
+function buildAppPath(publicPath, subapp) {
+    const normalizedPublicPath = publicPath.replace(/\/+$/, '');
+    if (!subapp) {
+        return normalizedPublicPath ? `${normalizedPublicPath}/` : '/';
+    }
+    const normalizedSubapp = subapp.replace(/^\/+|\/+$/g, '');
+    return `${normalizedPublicPath ? normalizedPublicPath : ''}/apps/${normalizedSubapp}/`;
+}
+export function resolveAppUrlFromApiBaseUrl(apiBaseUrl) {
+    const value = String(apiBaseUrl ?? '').trim();
+    if (!value) {
+        return '';
+    }
+    try {
+        const url = new URL(value);
+        const subappMatch = url.pathname.match(/^(.*)\/api\/__app\/([^/]+)\/?$/);
+        if (subappMatch) {
+            url.pathname = buildAppPath(subappMatch[1] ?? '', subappMatch[2]);
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        }
+        const appMatch = url.pathname.match(/^(.*)\/api\/?$/);
+        if (appMatch) {
+            url.pathname = buildAppPath(appMatch[1] ?? '');
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        }
+    }
+    catch {
+        return value;
+    }
+    return value;
+}
+export function appUrl(runtime) {
+    const resolvedFromApiBaseUrl = resolveAppUrlFromApiBaseUrl(runtime.env.apiBaseUrl ?? resolveApiBaseUrl(runtime.env.config));
+    if (resolvedFromApiBaseUrl) {
+        return resolvedFromApiBaseUrl;
+    }
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (port) {
+        return buildLocalAppUrl(port, runtime.env.config?.appPublicPath) ?? '';
+    }
+    return '';
+}
+export function appPath(runtime) {
+    if (runtime.kind === 'http') {
+        return '-';
+    }
+    const value = String(runtime.env.appPath ?? runtime.env.config.appPath ?? '').trim();
+    return value || '-';
+}
+export function sourcePath(runtime) {
+    if (runtime.kind === 'http' || runtime.kind === 'docker') {
+        return '-';
+    }
+    if (runtime.kind === 'local') {
+        return String(runtime.projectRoot ?? runtime.env.sourcePath ?? runtime.env.appRootPath ?? '').trim() || '-';
+    }
+    return String(runtime.env.config.appRootPath ?? '').trim() || '-';
+}
+export function storagePath(runtime) {
+    if (runtime.kind === 'http') {
+        return '-';
+    }
+    const value = String(runtime.env.storagePath ?? runtime.env.config.storagePath ?? '').trim();
+    return value || '-';
+}
+function collectErrorCodes(value) {
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectErrorCodes(item));
+    }
+    const out = [];
+    const record = value;
+    if (typeof record.code === 'string') {
+        out.push(record.code);
+    }
+    for (const key of ['data', 'error', 'errors']) {
+        out.push(...collectErrorCodes(record[key]));
+    }
+    return out;
+}
+function isAuthFailureData(value) {
+    const codes = collectErrorCodes(value);
+    return codes.some((code) => ['EMPTY_TOKEN', 'INVALID_TOKEN', 'EXPIRED_TOKEN', 'BLOCKED_TOKEN', 'EXPIRED_SESSION', 'NOT_EXIST_USER'].includes(code));
+}
+function isNetworkFailure(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return (error.name === 'AbortError' ||
+        /fetch failed|network|timeout|timed out|abort|ECONNREFUSED|ECONNRESET|ENOTFOUND|ETIMEDOUT|EAI_AGAIN|ENETUNREACH/i.test(error.message));
+}
+function isUnconfiguredFailure(error) {
+    return error instanceof Error && /missing (a )?base url|missing base URL/i.test(error.message);
+}
+function isAuthFailure(error) {
+    return (error instanceof Error &&
+        /EMPTY_TOKEN|INVALID_TOKEN|EXPIRED_TOKEN|BLOCKED_TOKEN|EXPIRED_SESSION|NOT_EXIST_USER|invalid_grant|sign in|signin|authentication failed/i.test(error.message));
+}
+export async function apiStatus(envName, config, options = {}) {
+    if (!resolveApiBaseUrl(config)) {
+        return 'unconfigured';
+    }
+    try {
+        const response = await executeRawApiRequest({
+            envName,
+            scope: options.scope,
+            method: 'GET',
+            path: '/auth:check',
+            timeoutMs: options.timeoutMs ?? 2000,
+        });
+        if (response.ok) {
+            return 'ok';
+        }
+        if (response.status === 401 || response.status === 403 || isAuthFailureData(response.data)) {
+            return 'auth failed';
+        }
+        return 'error';
+    }
+    catch (error) {
+        if (isUnconfiguredFailure(error)) {
+            return 'unconfigured';
+        }
+        if (isAuthFailure(error)) {
+            return 'auth failed';
+        }
+        if (isNetworkFailure(error)) {
+            return 'unreachable';
+        }
+        return 'error';
+    }
+}
+async function isLocalAppHealthy(runtime) {
+    const port = String(runtime.env.config.appPort ?? '').trim();
+    if (!port) {
+        return false;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1500);
+    try {
+        const response = await fetch(`http://127.0.0.1:${port}/api/__health_check`, {
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        return response.ok && text.trim().toLowerCase() === 'ok';
+    }
+    catch (_error) {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function dockerStatus(containerName) {
+    if (!(await dockerContainerExists(containerName))) {
+        return 'missing';
+    }
+    return (await dockerContainerIsRunning(containerName)) ? 'running' : 'stopped';
+}
+export async function dbStatus(runtime) {
+    if (!runtime.env.config.builtinDb) {
+        return runtime.kind === 'http' ? 'external' : '-';
+    }
+    if (runtime.kind === 'http') {
+        return 'external';
+    }
+    if (runtime.kind === 'ssh') {
+        return '-';
+    }
+    const dbDialect = String(runtime.env.config.dbDialect ?? 'postgres').trim() || 'postgres';
+    const containerName = buildDockerDbContainerName(runtime.envName, dbDialect, runtime.dockerContainerPrefix || runtime.workspaceName);
+    return await dockerStatus(containerName);
+}
+export async function runtimeStatus(runtime) {
+    if (runtime.kind === 'http') {
+        return 'http';
+    }
+    if (runtime.kind === 'ssh') {
+        return 'ssh';
+    }
+    if (runtime.kind === 'docker') {
+        return await dockerStatus(runtime.containerName);
+    }
+    return (await isLocalAppHealthy(runtime)) ? 'running' : 'stopped';
+}