@nocobase/cli 2.1.0-alpha.46 → 2.1.0-alpha.47

package/dist/commands/revision/create.js

@@ -0,0 +1,89 @@
+/**
+ * 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 { executeRawApiRequest } from '../../lib/api-client.js';
+import { ensureCrossEnvConfirmed } from '../../lib/env-guard.js';
+export default class RevisionCreate extends Command {
+    static summary = 'Save the current NocoBase build as a restorable revision';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "description here"',
+        '<%= config.bin %> <%= command.id %> --env app1 "description here"',
+    ];
+    static args = {
+        description: Args.string({
+            required: true,
+            description: 'Revision description, up to 2000 characters.',
+        }),
+    };
+    static flags = {
+        'api-base-url': Flags.string({
+            description: 'NocoBase API base URL, for example http://localhost:13000/api',
+        }),
+        env: Flags.string({
+            char: 'e',
+            description: 'Environment name',
+        }),
+        role: Flags.string({
+            description: 'Role override, sent as X-Role',
+        }),
+        token: Flags.string({
+            char: 't',
+            description: 'API key override',
+        }),
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Confirm using --env when it targets a different env than the current env',
+            default: false,
+        }),
+        'json-output': Flags.boolean({
+            char: 'j',
+            description: 'Print raw JSON response',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(RevisionCreate);
+        const description = args.description;
+        if (description.length > 2000) {
+            this.error('Description length should not be over 2000');
+        }
+        const confirmed = await ensureCrossEnvConfirmed({
+            command: this,
+            requestedEnv: flags.env,
+            yes: flags.yes,
+        });
+        if (!confirmed) {
+            return;
+        }
+        const response = await executeRawApiRequest({
+            envName: flags.env,
+            baseUrl: flags['api-base-url'],
+            role: flags.role,
+            token: flags.token,
+            method: 'POST',
+            path: '/app:publishEvent',
+            body: {
+                plugin: 'plugin-version-control',
+                command: 'revision:create',
+                payload: {
+                    description,
+                },
+            },
+        });
+        if (!response.ok) {
+            this.error(`Request failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`);
+        }
+        if (flags['json-output']) {
+            this.log(JSON.stringify(response.data, null, 2));
+            return;
+        }
+        this.log(`HTTP ${response.status}`);
+    }
+}

package/dist/commands/source/test.js

@@ -14,7 +14,7 @@ import Install from '../install.js';
 import { defaultWorkspaceName } from '../../lib/app-runtime.js';
 import { resolveCliLocale } from '../../lib/cli-locale.js';
 import { findAvailableTcpPort, validateAvailableTcpPort } from '../../lib/prompt-validators.js';
-import { commandSucceeds, resolveProjectCwd, run, runNocoBaseCommand } from '../../lib/run-npm.js';
+import { commandSucceeds, ensureDockerDaemonRunning, resolveProjectCwd, run, runNocoBaseCommand, } from '../../lib/run-npm.js';
 import { failTask, printInfo, setVerboseMode, startTask, succeedTask } from '../../lib/ui.js';
 const DEFAULT_DB_HOST = '127.0.0.1';
 const DEFAULT_DB_DATABASE = 'nocobase-test';
@@ -48,11 +48,11 @@ const DEFAULT_DB_PORTS = {
 };
 const TCP_PORT_READY_SCRIPT = [
     "const net = require('node:net');",
-    "const port = Number(process.argv.at(-1));",
+    'const port = Number(process.argv.at(-1));',
     "const socket = net.createConnection({ host: '127.0.0.1', port });",
     "socket.once('connect', () => { socket.end(); process.exit(0); });",
     "socket.once('error', () => process.exit(1));",
-    "setTimeout(() => { socket.destroy(); process.exit(1); }, 200).unref();",
+    'setTimeout(() => { socket.destroy(); process.exit(1); }, 200).unref();',
 ].join('\n');
 function inferTestEnv(paths) {
     const first = String(paths[0] ?? '').trim();
@@ -60,9 +60,7 @@ function inferTestEnv(paths) {
         return undefined;
     }
     const normalized = first.split('\\').join('/');
-    if (normalized.includes('/client/')
-        || normalized.includes('/client-v2/')
-        || normalized.includes('/flow-engine/')) {
+    if (normalized.includes('/client/') || normalized.includes('/client-v2/') || normalized.includes('/flow-engine/')) {
         return 'client-side';
     }
     return 'server-side';
@@ -77,9 +75,7 @@ function defaultTestDbPort(dbDialect) {
     return String(DEFAULT_DB_PORTS[dbDialect] ?? DEFAULT_DB_PORTS.postgres);
 }
 function defaultTestDbImage(dbDialect) {
-    const defaults = resolveCliLocale(process.env.NB_LOCALE) === 'zh-CN'
-        ? DEFAULT_TEST_DB_IMAGES_ZH_CN
-        : DEFAULT_TEST_DB_IMAGES;
+    const defaults = resolveCliLocale(process.env.NB_LOCALE) === 'zh-CN' ? DEFAULT_TEST_DB_IMAGES_ZH_CN : DEFAULT_TEST_DB_IMAGES;
     return defaults[dbDialect] ?? defaults.postgres;
 }
 function delay(ms) {
@@ -174,9 +170,11 @@ async function startTestDbDistributor(params) {
         if (code === 0) {
             return;
         }
-        childError = childError ?? new Error(signal
-            ? `test DB distributor exited due to signal ${signal}`
-            : `test DB distributor exited with code ${code ?? 'unknown'}`);
+        childError =
+            childError ??
+                new Error(signal
+                    ? `test DB distributor exited due to signal ${signal}`
+                    : `test DB distributor exited with code ${code ?? 'unknown'}`);
     });
     try {
         await waitForTcpPortReady(port);
@@ -194,6 +192,7 @@ async function startTestDbDistributor(params) {
     };
 }
 async function ensureDockerNetwork(networkName, options) {
+    await ensureDockerDaemonRunning('prepare Docker resources for the built-in test database');
     if (await commandSucceeds('docker', ['network', 'inspect', networkName])) {
         return;
     }
@@ -440,8 +439,8 @@ export default class SourceTest extends Command {
                 server: flags.server,
                 client: flags.client,
                 paths: args.paths ?? [],
-            })
-                && supportsTestDbDistributor(testDbConfig.env.DB_DIALECT)) {
+            }) &&
+                supportsTestDbDistributor(testDbConfig.env.DB_DIALECT)) {
                 testDbDistributor = await startTestDbDistributor({
                     cwd,
                     env: testDbConfig.env,

package/dist/lib/app-health.js

@@ -6,6 +6,7 @@
  * 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 { buildLocalApiBaseUrl, buildLocalAppUrl } from './app-public-path.js';
 import { startDockerLogFollower } from './docker-log-stream.js';
 import { printInfo } from './ui.js';
 const APP_HEALTH_CHECK_INTERVAL_MS = 2_000;
@@ -56,14 +57,13 @@ async function requestAppHealthCheck(params) {
 }
 export class AppHealthCheckError extends Error {
 }
-export function formatAppUrl(port) {
-    const value = trimValue(port);
-    return value ? `http://127.0.0.1:${value}` : undefined;
+export function formatAppUrl(port, appPublicPath) {
+    return buildLocalAppUrl(port, appPublicPath);
 }
 export function resolveManagedAppApiBaseUrl(runtime, options) {
     const override = trimValue(options?.portOverride);
     if (override) {
-        return `http://127.0.0.1:${override}/api`;
+        return buildLocalApiBaseUrl(override, runtime.env.config?.appPublicPath);
     }
     const baseUrl = trimValue(runtime.env.baseUrl);
     if (baseUrl) {
@@ -72,7 +72,7 @@ export function resolveManagedAppApiBaseUrl(runtime, options) {
     const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
         ? ''
         : trimValue(runtime.env.appPort);
-    return appPort ? `http://127.0.0.1:${appPort}/api` : undefined;
+    return buildLocalApiBaseUrl(appPort, runtime.env.config?.appPublicPath);
 }
 export async function isAppReady(apiBaseUrl, options) {
     const baseUrl = trimValue(apiBaseUrl);

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

@@ -7,18 +7,20 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { mkdir, readdir } from 'node:fs/promises';
-import { dockerContainerExists, runLocalNocoBaseCommand, startDockerContainer } from './app-runtime.js';
+import { resolveAppPublicPath } from './app-public-path.js';
+import { dockerContainerExists, managedAppLifecycleEnvVars, runLocalNocoBaseCommand, startDockerContainer, } from './app-runtime.js';
 import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
-import { resolveConfiguredEnvPath } from './cli-home.js';
+import { resolveConfiguredStoragePath } from './env-paths.js';
 import { resolveDockerEnvFileArg } from "./docker-env-file.js";
 import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "./docker-image.js";
-import { commandSucceeds, run } from './run-npm.js';
+import { commandSucceeds, ensureDockerDaemonRunning, run } from './run-npm.js';
 import Install from '../commands/install.js';
 const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
 function commandStdio(verbose) {
     return verbose ? 'inherit' : 'ignore';
 }
 async function ensureDockerNetwork(networkName) {
+    await ensureDockerDaemonRunning('prepare Docker resources for this environment');
     if (await commandSucceeds('docker', ['network', 'inspect', networkName])) {
         return;
     }
@@ -44,6 +46,16 @@ function pushOptionalEnvArg(args, key, value) {
         args.push('-e', `${key}=${String(value)}`);
     }
 }
+function resolveDockerClientAssetsExtractEnabled(envValue) {
+    const text = trimValue(envValue).toLowerCase();
+    if (!text) {
+        return true;
+    }
+    if (['0', 'false', 'no', 'off'].includes(text)) {
+        return false;
+    }
+    return true;
+}
 function normalizeDockerPlatform(value) {
     const text = trimValue(value);
     if (!text || text === 'auto') {
@@ -104,15 +116,13 @@ async function localProjectHasFiles(projectRoot) {
 }
 export async function buildSavedDockerRunArgs(runtime) {
     const config = runtime.env.config ?? {};
-    const configuredStoragePath = trimValue(config.storagePath);
-    const storagePath = configuredStoragePath
-        ? trimValue(resolveConfiguredEnvPath(configuredStoragePath))
-        : '';
+    const storagePath = trimValue(resolveConfiguredStoragePath(config));
     const envFile = await resolveDockerEnvFileArg(runtime.envName, config);
     const appPort = runtime.env.appPort === undefined || runtime.env.appPort === null
         ? ''
         : trimValue(runtime.env.appPort);
     const appKey = trimValue(config.appKey);
+    const appPublicPath = trimValue(config.appPublicPath);
     const timeZone = trimValue(config.timezone) || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
     const builtinDbConnection = config.builtinDb ? deriveBuiltinDbConnection(runtime) : undefined;
     const dbDialect = builtinDbConnection?.dbDialect || trimValue(config.dbDialect);
@@ -124,6 +134,7 @@ export async function buildSavedDockerRunArgs(runtime) {
     const dbSchema = trimValue(config.dbSchema);
     const dbTablePrefix = trimValue(config.dbTablePrefix);
     const dbUnderscored = typeof config.dbUnderscored === 'boolean' ? config.dbUnderscored : undefined;
+    const extractClientAssets = resolveDockerClientAssetsExtractEnabled(process.env.NOCOBASE_EXTRACT_CLIENT_ASSETS);
     const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
     const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
     const imageRef = resolveDockerImageRef(dockerRegistry, version, {
@@ -178,10 +189,13 @@ export async function buildSavedDockerRunArgs(runtime) {
     if (envFile) {
         args.push('--env-file', envFile);
     }
-    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`);
+    const lifecycleEnvVars = managedAppLifecycleEnvVars();
+    args.push('-e', `APP_ENV=${lifecycleEnvVars.APP_ENV}`, '-e', `NODE_ENV=${lifecycleEnvVars.NODE_ENV}`, '-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`);
+    pushOptionalEnvArg(args, 'APP_PUBLIC_PATH', appPublicPath ? resolveAppPublicPath(appPublicPath) : undefined);
     pushOptionalEnvArg(args, 'DB_SCHEMA', dbSchema || undefined);
     pushOptionalEnvArg(args, 'DB_TABLE_PREFIX', dbTablePrefix || undefined);
     pushOptionalEnvArg(args, 'DB_UNDERSCORED', dbUnderscored);
+    pushOptionalEnvArg(args, 'NOCOBASE_EXTRACT_CLIENT_ASSETS', extractClientAssets);
     args.push(imageRef);
     return {
         appPort: appPort || undefined,
@@ -220,6 +234,7 @@ export async function ensureBuiltinDbReady(runtime, options) {
         envName: runtime.envName,
         workspaceName: runtime.workspaceName,
         dockerContainerPrefix: runtime.dockerContainerPrefix,
+        appPath: config.appPath,
         storagePath: config.storagePath,
         source: runtime.source,
         dbDialect: builtinDbConnection.dbDialect,
@@ -305,6 +320,7 @@ export async function ensureLocalPostinstall(runtime, options) {
     options?.onStartTask?.(`Running local postinstall for "${runtime.envName}"...`);
     try {
         await runLocalNocoBaseCommand(runtime, ['postinstall'], {
+            env: options?.env,
             stdio: commandStdio(options?.verbose),
         });
         options?.onSucceedTask?.(`Local postinstall finished for "${runtime.envName}".`);

package/dist/lib/app-public-path.js

@@ -0,0 +1,80 @@
+/**
+ * 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 { readFile } from 'node:fs/promises';
+import path from 'node:path';
+const DEFAULT_APP_PUBLIC_PATH = '/';
+const DEFAULT_DIST_SEGMENT = 'dist';
+const DIST_CLIENT_DIR = 'dist-client';
+const DIST_CLIENT_ACTIVE_VERSION_FILE = 'active-version';
+function trimValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+export function resolveAppPublicPath(appPublicPath = DEFAULT_APP_PUBLIC_PATH) {
+    const normalized = String(appPublicPath || DEFAULT_APP_PUBLIC_PATH)
+        .trim()
+        .replace(/\/+/g, '/')
+        .replace(/\/?$/, '/');
+    const withLeadingSlash = normalized.startsWith('/') ? normalized : `/${normalized}`;
+    return withLeadingSlash || DEFAULT_APP_PUBLIC_PATH;
+}
+export function appendAppPublicPath(appPublicPath, segment, options) {
+    const publicPath = resolveAppPublicPath(appPublicPath).replace(/\/+$/, '');
+    const normalizedSegment = String(segment || '')
+        .trim()
+        .replace(/^\/+/, '')
+        .replace(options?.trailingSlash ? /\/+$/ : /\/*$/, '');
+    const joinedPath = normalizedSegment ? `${publicPath}/${normalizedSegment}` : publicPath || '/';
+    if (options?.trailingSlash) {
+        return joinedPath.endsWith('/') ? joinedPath : `${joinedPath}/`;
+    }
+    return joinedPath || '/';
+}
+export function resolveDistPublicPath(appPublicPath) {
+    return appendAppPublicPath(appPublicPath, DEFAULT_DIST_SEGMENT, { trailingSlash: true });
+}
+export function buildDefaultCdnBaseUrl(appPublicPath, version) {
+    const normalizedVersion = String(version || '')
+        .trim()
+        .replace(/^\/+|\/+$/g, '');
+    return `${resolveDistPublicPath(appPublicPath)}${normalizedVersion}/`;
+}
+export function buildLocalAppUrl(port, appPublicPath) {
+    const value = trimValue(port);
+    if (!value) {
+        return undefined;
+    }
+    const publicPath = resolveAppPublicPath(appPublicPath);
+    return publicPath === '/' ? `http://127.0.0.1:${value}` : `http://127.0.0.1:${value}${publicPath}`;
+}
+export function buildLocalApiBaseUrl(port, appPublicPath) {
+    const value = trimValue(port);
+    if (!value) {
+        return undefined;
+    }
+    return `http://127.0.0.1:${value}${appendAppPublicPath(appPublicPath, 'api', { trailingSlash: false })}`;
+}
+export function resolveDistClientRoot(storagePath) {
+    return path.join(storagePath, DIST_CLIENT_DIR);
+}
+export function resolveDistClientVersionRoot(storagePath, version) {
+    return path.join(resolveDistClientRoot(storagePath), version);
+}
+export function resolveDistClientActiveVersionFile(storagePath) {
+    return path.join(resolveDistClientRoot(storagePath), DIST_CLIENT_ACTIVE_VERSION_FILE);
+}
+export async function readDistClientActiveVersion(storagePath) {
+    try {
+        const content = await readFile(resolveDistClientActiveVersionFile(storagePath), 'utf8');
+        return trimValue(content);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lib/app-runtime.js

@@ -10,6 +10,7 @@ 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 { resolveManagedLocalEnvFilePath } from './managed-env-file.js';
 import { commandOutput, commandSucceeds, run, runNocoBaseCommand } from './run-npm.js';
 import { buildRuntimeEnvVars } from './runtime-env-vars.js';
 const DOCKER_APP_WORKDIR = '/app/nocobase';
@@ -84,7 +85,7 @@ export async function resolveManagedAppRuntime(envName) {
             env,
             envName: resolvedName,
             source: source === 'git' ? 'git' : source === 'npm' ? 'npm' : 'local',
-            projectRoot: env.appRootPath,
+            projectRoot: env.sourcePath,
             dockerNetworkName,
             dockerContainerPrefix,
             workspaceName: dockerNetworkName,
@@ -115,12 +116,20 @@ export function formatMissingManagedAppEnvMessage(envName) {
     }
     return 'No NocoBase env is configured yet. Run `nb init --ui` to create one first.';
 }
+export function managedAppLifecycleEnvVars() {
+    return {
+        APP_ENV: 'production',
+        NODE_ENV: 'production',
+    };
+}
 export async function runLocalNocoBaseCommand(runtime, args, options) {
     const envVars = await buildRuntimeEnvVars(runtime);
+    const appEnvPath = resolveManagedLocalEnvFilePath(runtime);
     await runNocoBaseCommand(args, {
         cwd: runtime.projectRoot,
         env: {
             ...envVars,
+            APP_ENV_PATH: appEnvPath,
             ...options?.env,
         },
         stdio: options?.stdio,

package/dist/lib/auth-store.js

@@ -8,8 +8,10 @@
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
+import { resolveAppPublicPath } from './app-public-path.js';
 import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
 import { normalizeCliLocale } from './cli-locale.js';
+import { inferConfiguredAppPathFromLegacyConfig, resolveConfiguredAppPath, resolveConfiguredSourcePath, resolveConfiguredStoragePath, } from './env-paths.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
@@ -62,7 +64,7 @@ export function resolveEnvKind(config) {
     if (source === 'npm' || source === 'git' || source === 'local') {
         return 'local';
     }
-    if (String(config.appRootPath ?? '').trim()) {
+    if (String(config.appPath ?? '').trim() || String(config.appRootPath ?? '').trim()) {
         return 'local';
     }
     if (readEnvApiBaseUrl(config) || config.auth) {
@@ -81,16 +83,31 @@ function normalizeEnvConfigEntry(entry) {
         ...rest,
         ...(normalizedKind ? { kind: normalizedKind } : {}),
         ...(apiBaseUrl !== undefined ? { apiBaseUrl } : {}),
+        ...(normalizeOptionalString(entry.appPublicPath) ? { appPublicPath: resolveAppPublicPath(entry.appPublicPath) } : {}),
     };
 }
 function normalizeAuthConfig(config) {
     const settings = config.settings ?? {};
     const locale = normalizeOptionalCliLocale(settings.locale);
+    const defaultUiHost = normalizeOptionalString(settings.init?.defaultUiHost);
+    const defaultApiHost = normalizeOptionalString(settings.init?.defaultApiHost);
     const updatePolicy = normalizeOptionalCliUpdatePolicy(settings.update?.policy);
+    const logRetentionDays = typeof settings.log?.retentionDays === 'number' && Number.isInteger(settings.log.retentionDays)
+        ? settings.log.retentionDays
+        : undefined;
+    const logEnabled = typeof settings.log?.enabled === 'boolean' ? settings.log.enabled : undefined;
     return {
         name: config.name || config.dockerResourcePrefix,
         settings: {
             ...(locale ? { locale } : {}),
+            ...(defaultUiHost || defaultApiHost
+                ? {
+                    init: {
+                        ...(defaultUiHost ? { defaultUiHost } : {}),
+                        ...(defaultApiHost ? { defaultApiHost } : {}),
+                    },
+                }
+                : {}),
             ...(updatePolicy ? { update: { policy: updatePolicy } } : {}),
             ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
             ...(settings.docker?.network || settings.docker?.containerPrefix
@@ -103,15 +120,39 @@ function normalizeAuthConfig(config) {
                     },
                 }
                 : {}),
-            ...(settings.bin?.docker || settings.bin?.git || settings.bin?.yarn
+            ...(settings.bin?.docker || settings.bin?.caddy || settings.bin?.git || settings.bin?.nginx || settings.bin?.yarn
                 ? {
                     bin: {
                         ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
+                        ...(settings.bin?.caddy ? { caddy: normalizeOptionalString(settings.bin.caddy) } : {}),
                         ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
+                        ...(settings.bin?.nginx ? { nginx: normalizeOptionalString(settings.bin.nginx) } : {}),
                         ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
                     },
                 }
                 : {}),
+            ...(settings.proxy?.nbCliRoot ||
+                settings.proxy?.upstreamHost ||
+                settings.proxy?.host
+                ? {
+                    proxy: {
+                        ...(settings.proxy?.nbCliRoot ? { nbCliRoot: normalizeOptionalString(settings.proxy.nbCliRoot) } : {}),
+                        ...(settings.proxy?.upstreamHost || settings.proxy?.host
+                            ? {
+                                upstreamHost: normalizeOptionalString(settings.proxy?.upstreamHost ?? settings.proxy.host),
+                            }
+                            : {}),
+                    },
+                }
+                : {}),
+            ...(logEnabled !== undefined || logRetentionDays !== undefined
+                ? {
+                    log: {
+                        ...(logEnabled !== undefined ? { enabled: logEnabled } : {}),
+                        ...(logRetentionDays !== undefined ? { retentionDays: logRetentionDays } : {}),
+                    },
+                }
+                : {}),
         },
         lastEnv: config.lastEnv ||
             config.currentEnv ||
@@ -205,7 +246,29 @@ export class Env {
                 return configuredPath;
             }
         }
-        return resolveConfiguredEnvPath(this.config.appRootPath) ?? resolveEnvRelativePath('.');
+        const legacyPath = resolveConfiguredEnvPath(this.config.appRootPath);
+        if (legacyPath) {
+            return legacyPath;
+        }
+        return this.kind === 'local' ? this.sourcePath : resolveEnvRelativePath('.');
+    }
+    get appPath() {
+        if (this.kind === 'ssh') {
+            const configuredPath = String(this.config.appPath ?? inferConfiguredAppPathFromLegacyConfig(this.config) ?? '').trim();
+            if (configuredPath) {
+                return configuredPath;
+            }
+        }
+        return resolveConfiguredAppPath(this.config) ?? resolveEnvRelativePath('.');
+    }
+    get sourcePath() {
+        if (this.kind === 'ssh') {
+            const configuredPath = String(this.config.appRootPath ?? '').trim();
+            if (configuredPath) {
+                return configuredPath;
+            }
+        }
+        return resolveConfiguredSourcePath(this.config) ?? path.join(this.appPath, 'source');
     }
     get storagePath() {
         if (this.kind === 'ssh') {
@@ -214,7 +277,13 @@ export class Env {
                 return configuredPath;
             }
         }
-        return resolveConfiguredEnvPath(this.config.storagePath) ?? resolveEnvRelativePath('.');
+        const resolvedStoragePath = resolveConfiguredStoragePath(this.config);
+        if (resolvedStoragePath) {
+            return resolvedStoragePath;
+        }
+        return this.kind === 'local' || this.kind === 'docker'
+            ? path.join(this.appPath, 'storage')
+            : resolveEnvRelativePath('.');
     }
     get appPort() {
         return this.config.appPort;
@@ -230,6 +299,8 @@ export class Env {
             out[key] = String(value);
         };
         put('APP_PORT', this.appPort);
+        put('APP_PUBLIC_PATH', this.config.appPublicPath ? resolveAppPublicPath(this.config.appPublicPath) : undefined);
+        put('CDN_BASE_URL', this.config.cdnBaseUrl);
         put('APP_KEY', this.config.appKey);
         put('TZ', this.config.timezone);
         put('DB_DIALECT', this.config.dbDialect);
@@ -358,6 +429,39 @@ export async function updateEnvConnection(envName, updates, options = {}) {
         };
     }, options);
 }
+export async function replaceEnvConfig(envName, config, options = {}) {
+    await writeEnv(envName, (previous) => {
+        if (!previous) {
+            throw new Error(`Env "${envName}" is not configured`);
+        }
+        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, ...rest } = config;
+        const nextApiBaseUrl = readEnvApiBaseUrl(config);
+        const previousApiBaseUrl = readEnvApiBaseUrl(previous);
+        const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
+        const previousAuthType = resolveConfiguredAuthType(previous);
+        const nextAuthType = normalizeConfiguredAuthType(authType) ?? (accessToken ? 'token' : undefined);
+        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) : undefined;
+        const nextAuth = accessToken
+            ? {
+                type: 'token',
+                accessToken,
+            }
+            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
+                ? previous.auth
+                : undefined;
+        const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        const authTypeChanged = previousAuthType !== nextAuthType;
+        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
+        return {
+            ...rest,
+            ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
+            ...(nextAuthType ? { authType: nextAuthType } : {}),
+            ...(nextAuthUsername ? { authUsername: nextAuthUsername } : {}),
+            ...(nextAuth ? { auth: nextAuth } : {}),
+            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
+        };
+    }, options);
+}
 export async function setEnvOauthSession(envName, auth, options = {}) {
     await writeEnv(envName, (previous) => ({
         ...previous,
@@ -375,6 +479,17 @@ export async function setEnvRuntime(envName, runtime, options = {}) {
     };
     await saveAuthConfig(config, options);
 }
+export async function clearEnvRootSetup(envName, options = {}) {
+    const config = await loadExactAuthConfig(options);
+    const current = config.envs[envName];
+    if (!current) {
+        return false;
+    }
+    const { rootUsername: _rootUsername, rootEmail: _rootEmail, rootPassword: _rootPassword, rootNickname: _rootNickname, ...rest } = current;
+    config.envs[envName] = rest;
+    await saveAuthConfig(config, options);
+    return true;
+}
 export async function removeEnv(envName, options = {}) {
     const config = await loadExactAuthConfig(options);
     if (!config.envs[envName]) {