@nocobase/cli 2.1.0-alpha.45 → 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/self/update.js

@@ -8,14 +8,29 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { confirm } from "../../lib/inquirer.js";
+import { updateNocoBaseSkills } from '../../lib/skills-manager.js';
 import { setVerboseMode } from '../../lib/ui.js';
 import { formatSelfUpdateUnavailableMessage, formatUnsupportedSelfUpdateMessage, inspectSelfStatus, updateSelf, } from '../../lib/self-manager.js';
+function formatSkillsUpdateMessage(result, verbose) {
+    if (result.action === 'noop') {
+        if (result.reason === 'not-installed') {
+            return verbose
+                ? 'NocoBase AI coding skills are not installed globally. Run `nb skills install` first.'
+                : 'Skipped skills update because NocoBase AI coding skills are not installed.';
+        }
+        return verbose
+            ? 'NocoBase AI coding skills are already up to date globally.'
+            : 'NocoBase AI coding skills are up to date.';
+    }
+    return verbose ? 'Updated the global NocoBase AI coding skills.' : 'Updated NocoBase AI coding skills globally.';
+}
 export default class SelfUpdate extends Command {
     static summary = 'Update the globally installed NocoBase CLI';
     static description = 'Update the current NocoBase CLI install when it is managed by a standard global npm install.';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> --yes',
+        '<%= config.bin %> <%= command.id %> --skills',
         '<%= config.bin %> <%= command.id %> --channel alpha --json',
     ];
     static flags = {
@@ -33,6 +48,10 @@ export default class SelfUpdate extends Command {
             description: 'Output the result as JSON',
             default: false,
         }),
+        skills: Flags.boolean({
+            description: 'Also update the globally installed NocoBase AI coding skills',
+            default: false,
+        }),
         verbose: Flags.boolean({
             description: 'Show detailed update output',
             default: false,
@@ -50,11 +69,14 @@ export default class SelfUpdate extends Command {
         if (!status.latestVersion && status.registryError) {
             this.error(formatSelfUpdateUnavailableMessage(status));
         }
+        let shouldUpdateSkills = flags.skills;
         if (!flags.yes && status.updateAvailable) {
             let confirmed = false;
             try {
                 confirmed = await confirm({
-                    message: `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion}?`,
+                    message: flags.skills
+                        ? `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion} and refresh the globally installed NocoBase AI coding skills?`
+                        : `Update ${status.packageName} from ${status.currentVersion} to ${status.latestVersion}?`,
                     default: false,
                 });
             }
@@ -69,6 +91,24 @@ export default class SelfUpdate extends Command {
             channel: flags.channel,
             verbose: flags.verbose,
         });
+        if (flags.skills && !flags.yes && !status.updateAvailable) {
+            let confirmed = false;
+            try {
+                confirmed = await confirm({
+                    message: 'Update the globally installed NocoBase AI coding skills?',
+                    default: true,
+                });
+            }
+            catch {
+                return;
+            }
+            shouldUpdateSkills = confirmed;
+        }
+        const skillsResult = shouldUpdateSkills
+            ? await updateNocoBaseSkills({
+                verbose: flags.verbose,
+            })
+            : undefined;
         if (flags.json) {
             this.log(JSON.stringify({
                 ok: true,
@@ -79,6 +119,17 @@ export default class SelfUpdate extends Command {
                 channel: result.status.channel,
                 fromVersion: result.status.currentVersion,
                 toVersion: result.targetVersion,
+                skills: skillsResult
+                    ? {
+                        action: skillsResult.action,
+                        reason: skillsResult.action === 'noop' ? skillsResult.reason : undefined,
+                        globalRoot: skillsResult.status.globalRoot,
+                        workspaceRoot: skillsResult.status.workspaceRoot,
+                        installedSkillNames: skillsResult.status.installedSkillNames,
+                        installedVersion: skillsResult.status.installedVersion,
+                        installedRef: skillsResult.status.installedRef,
+                    }
+                    : undefined,
             }, null, 2));
             return;
         }
@@ -86,10 +137,16 @@ export default class SelfUpdate extends Command {
             this.log(flags.verbose
                 ? `NocoBase CLI is already up to date at ${result.status.currentVersion}.`
                 : `NocoBase CLI is up to date: ${result.status.currentVersion}.`);
+            if (skillsResult) {
+                this.log(formatSkillsUpdateMessage(skillsResult, flags.verbose));
+            }
             return;
         }
         this.log(flags.verbose
             ? `Updated NocoBase CLI from ${result.status.currentVersion} using ${result.packageSpec}${result.targetVersion ? ` (latest ${result.status.channel} resolves to ${result.targetVersion})` : ''}.`
             : `Updated NocoBase CLI: ${result.status.currentVersion} -> ${result.targetVersion}.`);
+        if (skillsResult) {
+            this.log(formatSkillsUpdateMessage(skillsResult, flags.verbose));
+        }
     }
 }

package/dist/commands/source/dev.js

@@ -16,20 +16,20 @@ function formatUnsupportedRuntimeMessage(kind, envName) {
         return [
             `Can't run dev mode for "${envName}".`,
             'This env is managed by Docker, but `nb source dev` requires a local npm or Git source directory.',
-            `Use \`nb app logs --env ${envName}\` to inspect the Docker app, or create a source-based env with \`nb init --env ${envName} --source git\`.`,
+            `Use \`nb app logs --env ${envName}\` to inspect the Docker app, or create a source-based env with \`nb init --ui --env ${envName} --source git\`.`,
         ].join('\n');
     }
     if (kind === 'ssh') {
         return [
             `Can't run dev mode for "${envName}" yet.`,
             'SSH env support is reserved but not implemented yet.',
-            `Create a source-based env with \`nb init --env ${envName} --source git\` if you want local development mode right now.`,
+            `Create a source-based env with \`nb init --ui --env ${envName} --source git\` if you want local development mode right now.`,
         ].join('\n');
     }
     return [
         `Can't run dev mode for "${envName}".`,
         'This env only has an API connection, but `nb source dev` requires a local npm or Git source directory.',
-        `Create a source-based env with \`nb init --env ${envName} --source git\` if you want local development mode.`,
+        `Create a source-based env with \`nb init --ui --env ${envName} --source git\` if you want local development mode.`,
     ].join('\n');
 }
 function appUrlForPort(port) {
@@ -129,8 +129,8 @@ export default class SourceDev extends Command {
             this.error(formatUnsupportedRuntimeMessage(runtime.kind, runtime.envName));
         }
         announceTargetEnv(runtime.envName);
-        const devPort = flags.port
-            || (runtime.env.appPort !== undefined && runtime.env.appPort !== null
+        const devPort = flags.port ||
+            (runtime.env.appPort !== undefined && runtime.env.appPort !== null
                 ? String(runtime.env.appPort).trim()
                 : undefined);
         const appUrl = appUrlForPort(devPort);

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,8 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
+import { 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;
 const APP_HEALTH_CHECK_TIMEOUT_MS = 600_000;
@@ -55,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) {
@@ -71,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);
@@ -99,34 +100,40 @@ export async function waitForAppReady(params) {
     let lastMessage = 'No response yet';
     let nextProgressLogAt = startedAt + progressLogIntervalMs;
     printInfo(`Waiting for NocoBase to become ready for "${params.envName}"...`);
-    while (Date.now() - startedAt < timeoutMs) {
-        const result = await requestAppHealthCheck({
-            healthCheckUrl,
-            fetchImpl: params.fetchImpl,
-            requestTimeoutMs: params.requestTimeoutMs,
-        });
-        if (result.ok) {
-            return;
-        }
-        lastMessage = result.message;
-        const now = Date.now();
-        if (now >= nextProgressLogAt) {
-            const elapsedSeconds = Math.max(1, Math.floor((now - startedAt) / 1000));
-            printInfo(`Still waiting for "${params.envName}"... (${elapsedSeconds}s elapsed)`);
-            while (nextProgressLogAt <= now) {
-                nextProgressLogAt += progressLogIntervalMs;
+    const dockerLogFollower = params.verbose && params.containerName ? startDockerLogFollower(params.containerName) : undefined;
+    try {
+        while (Date.now() - startedAt < timeoutMs) {
+            const result = await requestAppHealthCheck({
+                healthCheckUrl,
+                fetchImpl: params.fetchImpl,
+                requestTimeoutMs: params.requestTimeoutMs,
+            });
+            if (result.ok) {
+                return;
             }
+            lastMessage = result.message;
+            const now = Date.now();
+            if (now >= nextProgressLogAt) {
+                const elapsedSeconds = Math.max(1, Math.floor((now - startedAt) / 1000));
+                printInfo(`Still waiting for "${params.envName}"... (${elapsedSeconds}s elapsed)`);
+                while (nextProgressLogAt <= now) {
+                    nextProgressLogAt += progressLogIntervalMs;
+                }
+            }
+            const remainingMs = timeoutMs - (Date.now() - startedAt);
+            if (remainingMs <= 0) {
+                break;
+            }
+            await sleep(Math.min(intervalMs, remainingMs));
         }
-        const remainingMs = timeoutMs - (Date.now() - startedAt);
-        if (remainingMs <= 0) {
-            break;
-        }
-        await sleep(Math.min(intervalMs, remainingMs));
+        const hints = [
+            params.logHint,
+            params.containerName ? `docker logs ${params.containerName}` : undefined,
+        ].filter(Boolean);
+        const hintText = hints.length > 0 ? ` ${hints.join(' ')}` : '';
+        throw new AppHealthCheckError(`NocoBase did not become ready in time for "${params.envName}". Expected \`${healthCheckUrl}\` to respond with \`ok\`, but the last status was: ${lastMessage}.${hintText}`);
+    }
+    finally {
+        await dockerLogFollower?.stop();
     }
-    const hints = [
-        params.logHint,
-        params.containerName ? `docker logs ${params.containerName}` : undefined,
-    ].filter(Boolean);
-    const hintText = hints.length > 0 ? ` ${hints.join(' ')}` : '';
-    throw new AppHealthCheckError(`NocoBase did not become ready in time for "${params.envName}". Expected \`${healthCheckUrl}\` to respond with \`ok\`, but the last status was: ${lastMessage}.${hintText}`);
 }

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') {
@@ -82,7 +94,7 @@ function formatSavedDockerSettingsIncomplete(envName, missing) {
     return [
         `Can't start NocoBase for "${envName}" yet.`,
         `The saved Docker settings for this env are incomplete. Missing: ${missing.join(', ')}.`,
-        'Re-run `nb init` or `nb env add` to refresh this env config, then try again.',
+        `Re-run \`nb init --ui --env ${envName}\` to refresh this env config, then try again.`,
     ].join('\n');
 }
 function formatDockerAppRecreateFailure(envName, message) {
@@ -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,
@@ -110,17 +111,25 @@ export function formatMissingManagedAppEnvMessage(envName) {
     if (requested) {
         return [
             `Env "${requested}" is not configured in this workspace.`,
-            `If you want to create a new NocoBase AI environment, run \`nb init --env ${requested}\` first.`,
+            `If you want to create a new NocoBase AI environment, run \`nb init --ui --env ${requested}\` first.`,
         ].join('\n');
     }
-    return 'No NocoBase env is configured yet. Run `nb init` to create one first.';
+    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,