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

package/dist/lib/command-log.js

@@ -0,0 +1,284 @@
+/**
+ * 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 fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { resolveCliHomeDir } from './cli-home.js';
+import { DEFAULT_LOG_ENABLED, DEFAULT_LOG_RETENTION_DAYS, getCliConfigValue } from './cli-config.js';
+const ACTIVE_LOG_FILE_ENV = 'NB_CLI_ACTIVE_LOG_FILE';
+const ACTIVE_META_FILE_ENV = 'NB_CLI_ACTIVE_META_FILE';
+const LOG_DIR_ENV = 'NB_CLI_LOG_DIR';
+const LOG_DISABLED_ENV = 'NB_CLI_LOG_DISABLED';
+const ANSI_ESCAPE_PATTERN = new RegExp(String.raw `\u001B\[[0-?]*[ -/]*[@-~]`, 'g');
+const CLEANUP_STATE_FILE = '.cleanup-state.json';
+const CLEANUP_INTERVAL_MS = 12 * 60 * 60 * 1000;
+function isTruthyEnvFlag(value) {
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function pad(value) {
+    return String(value).padStart(2, '0');
+}
+function formatDateParts(date) {
+    const year = date.getFullYear();
+    const month = pad(date.getMonth() + 1);
+    const day = pad(date.getDate());
+    const hour = pad(date.getHours());
+    const minute = pad(date.getMinutes());
+    const second = pad(date.getSeconds());
+    return {
+        dayKey: `${year}-${month}-${day}`,
+        timestampKey: `${year}${month}${day}-${hour}${minute}${second}`,
+    };
+}
+function sanitizeFileNameSegment(value) {
+    const normalized = value
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+    return normalized || 'command';
+}
+function resolveSessionDirName(sessionId) {
+    const trimmed = String(sessionId ?? '').trim();
+    if (!trimmed) {
+        return 'no-session';
+    }
+    return sanitizeFileNameSegment(trimmed);
+}
+export function stripAnsi(value) {
+    return value.replace(ANSI_ESCAPE_PATTERN, '');
+}
+export function shouldEnableCommandLog(env = process.env) {
+    return !isTruthyEnvFlag(env[LOG_DISABLED_ENV]);
+}
+export function resolveCommandLogDir(env = process.env) {
+    if (!shouldEnableCommandLog(env)) {
+        return undefined;
+    }
+    const configured = String(env[LOG_DIR_ENV] ?? '').trim();
+    if (configured) {
+        return path.resolve(configured);
+    }
+    return path.join(resolveCliHomeDir(), 'logs');
+}
+export function getActiveCommandLogFile(env = process.env) {
+    const value = String(env[ACTIVE_LOG_FILE_ENV] ?? '').trim();
+    return value || undefined;
+}
+function readActiveCommandMetaFile(env = process.env) {
+    const value = String(env[ACTIVE_META_FILE_ENV] ?? '').trim();
+    return value || undefined;
+}
+export function hasActiveCommandLog(env = process.env) {
+    return Boolean(getActiveCommandLogFile(env));
+}
+export function sanitizeArgv(argv) {
+    const sensitiveFlags = new Set(['--token', '--access-token', '--password', '--secret']);
+    const sanitized = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (sensitiveFlags.has(token)) {
+            sanitized.push(token);
+            if (index + 1 < argv.length) {
+                sanitized.push('***');
+                index += 1;
+            }
+            continue;
+        }
+        const matched = token.match(/^(--(?:token|access-token|password|secret))=(.*)$/);
+        if (matched) {
+            sanitized.push(`${matched[1]}=***`);
+            continue;
+        }
+        sanitized.push(token);
+    }
+    return sanitized;
+}
+export function getCommandLogCommandId(argv) {
+    const positional = argv.filter((token) => token && !token.startsWith('-'));
+    if (positional.length === 0) {
+        return 'command';
+    }
+    const commandPath = positional[0] === 'api' ? positional.slice(0, 3) : positional.slice(0, 2);
+    return sanitizeFileNameSegment(commandPath.join('-'));
+}
+function parseDateDirName(name) {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(name)) {
+        return undefined;
+    }
+    const parsed = new Date(`${name}T00:00:00.000Z`);
+    return Number.isNaN(parsed.getTime()) ? undefined : parsed;
+}
+async function readCleanupState(filePath) {
+    try {
+        return JSON.parse(await fsp.readFile(filePath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+async function writeCleanupState(filePath, state) {
+    await fsp.writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+async function resolveCommandLogRetentionDays() {
+    const configured = await getCliConfigValue('log.retention-days').catch(() => String(DEFAULT_LOG_RETENTION_DAYS));
+    const parsed = Number.parseInt(String(configured).trim(), 10);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        return DEFAULT_LOG_RETENTION_DAYS;
+    }
+    return parsed;
+}
+async function resolveCommandLogEnabled() {
+    const configured = await getCliConfigValue('log.enabled').catch(() => String(DEFAULT_LOG_ENABLED));
+    const normalized = String(configured).trim().toLowerCase();
+    if (normalized === 'false') {
+        return false;
+    }
+    if (normalized === 'true') {
+        return true;
+    }
+    return DEFAULT_LOG_ENABLED;
+}
+async function cleanupCommandLogs(rootDir, retentionDays, now = new Date()) {
+    if (retentionDays === 0) {
+        return;
+    }
+    const entries = await fsp.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+    const cutoff = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    cutoff.setUTCDate(cutoff.getUTCDate() - retentionDays + 1);
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dirDate = parseDateDirName(entry.name);
+        if (!dirDate || dirDate >= cutoff) {
+            continue;
+        }
+        await fsp.rm(path.join(rootDir, entry.name), { recursive: true, force: true });
+    }
+}
+async function maybeCleanupCommandLogs(rootDir, env = process.env) {
+    await fsp.mkdir(rootDir, { recursive: true });
+    const stateFile = path.join(rootDir, CLEANUP_STATE_FILE);
+    const state = await readCleanupState(stateFile);
+    const lastCleanupAt = Date.parse(String(state.lastCleanupAt ?? ''));
+    if (!Number.isNaN(lastCleanupAt) && Date.now() - lastCleanupAt < CLEANUP_INTERVAL_MS) {
+        return;
+    }
+    const retentionDays = await resolveCommandLogRetentionDays();
+    await cleanupCommandLogs(rootDir, retentionDays);
+    await writeCleanupState(stateFile, { lastCleanupAt: new Date().toISOString() });
+}
+async function writeMetaFile(filePath, meta) {
+    await fsp.mkdir(path.dirname(filePath), { recursive: true });
+    await fsp.writeFile(filePath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+function writeMetaFileSync(filePath, meta) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
+}
+export async function initCommandLogSession(options) {
+    const env = options.env ?? process.env;
+    if (!shouldEnableCommandLog(env)) {
+        return undefined;
+    }
+    const enabled = await resolveCommandLogEnabled().catch(() => DEFAULT_LOG_ENABLED);
+    if (!enabled) {
+        return undefined;
+    }
+    const rootDir = resolveCommandLogDir(env);
+    if (!rootDir) {
+        return undefined;
+    }
+    await maybeCleanupCommandLogs(rootDir, env).catch(() => undefined);
+    const startedAt = options.startedAt ?? new Date();
+    const { dayKey, timestampKey } = formatDateParts(startedAt);
+    const commandId = getCommandLogCommandId(options.argv);
+    const fileStem = `${timestampKey}-${commandId}-${options.pid ?? process.pid}`;
+    const sessionDirName = resolveSessionDirName(options.sessionId);
+    const logDir = path.join(rootDir, dayKey, sessionDirName);
+    const logFile = path.join(logDir, `${fileStem}.log`);
+    const metaFile = path.join(logDir, `${fileStem}.meta.json`);
+    const meta = {
+        command: commandId,
+        argv: sanitizeArgv(options.argv),
+        cwd: options.cwd,
+        pid: options.pid ?? process.pid,
+        ppid: options.ppid ?? process.ppid,
+        sessionId: options.sessionId,
+        startedAt: startedAt.toISOString(),
+        logFile,
+        cliVersion: options.cliVersion,
+        nodeVersion: options.nodeVersion,
+        platform: options.platform,
+        interactive: options.interactive,
+        verbose: options.verbose,
+    };
+    await fsp.mkdir(logDir, { recursive: true });
+    await fsp.writeFile(logFile, '', 'utf8');
+    await writeMetaFile(metaFile, meta);
+    env[ACTIVE_LOG_FILE_ENV] = logFile;
+    env[ACTIVE_META_FILE_ENV] = metaFile;
+    return {
+        logFile,
+        metaFile,
+        meta,
+    };
+}
+export function finalizeCommandLogSessionSync(session, options = {}) {
+    if (!session) {
+        return;
+    }
+    const endedAt = options.endedAt ?? new Date();
+    const startedAtMs = Date.parse(session.meta.startedAt);
+    const nextMeta = {
+        ...session.meta,
+        endedAt: endedAt.toISOString(),
+        durationMs: Number.isNaN(startedAtMs) ? undefined : Math.max(0, endedAt.getTime() - startedAtMs),
+        exitCode: options.exitCode ?? session.meta.exitCode,
+        signal: options.signal ?? session.meta.signal,
+        errorMessage: options.errorMessage ?? session.meta.errorMessage,
+    };
+    writeMetaFileSync(session.metaFile, nextMeta);
+    session.meta = nextMeta;
+}
+export function appendCommandLogChunk(chunk, env = process.env) {
+    const logFile = getActiveCommandLogFile(env);
+    if (!logFile) {
+        return;
+    }
+    const text = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
+    if (!text) {
+        return;
+    }
+    fs.appendFileSync(logFile, stripAnsi(text), 'utf8');
+}
+export function installCommandLogWriteHooks(env = process.env) {
+    if (!hasActiveCommandLog(env)) {
+        return undefined;
+    }
+    const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+    const originalStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = ((chunk, encoding, callback) => {
+        appendCommandLogChunk(chunk, env);
+        return originalStdoutWrite(chunk, encoding, callback);
+    });
+    process.stderr.write = ((chunk, encoding, callback) => {
+        appendCommandLogChunk(chunk, env);
+        return originalStderrWrite(chunk, encoding, callback);
+    });
+    return () => {
+        process.stdout.write = originalStdoutWrite;
+        process.stderr.write = originalStderrWrite;
+    };
+}
+export function getActiveCommandMetaFile(env = process.env) {
+    return readActiveCommandMetaFile(env);
+}

package/dist/lib/docker-env-file.js

@@ -8,15 +8,23 @@
  */
 import { access } from 'node:fs/promises';
 import { resolveConfiguredEnvPath } from './cli-home.js';
+import { inferConfiguredAppPathFromLegacyConfig } from './env-paths.js';
 function trimValue(value) {
     const text = String(value ?? '').trim();
     return text || undefined;
 }
-export function defaultDockerEnvFilePath(envName) {
+function appendDotEnvPath(basePath) {
+    return `${basePath.replace(/[\\/]+$/, '')}/.env`;
+}
+export function defaultDockerEnvFilePath(envName, config) {
+    const appPath = inferConfiguredAppPathFromLegacyConfig(config ?? {});
+    if (appPath) {
+        return appendDotEnvPath(appPath);
+    }
     return `${envName}/.env`;
 }
 export function resolveConfiguredDockerEnvFilePath(envName, config) {
-    return trimValue(config?.envFile) || defaultDockerEnvFilePath(envName);
+    return trimValue(config?.envFile) || defaultDockerEnvFilePath(envName, config);
 }
 export function hasExplicitDockerEnvFile(config) {
     return Boolean(trimValue(config?.envFile));

package/dist/lib/docker-log-stream.js

@@ -0,0 +1,45 @@
+/**
+ * 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 { spawn } from 'node:child_process';
+const DEFAULT_DOCKER_LOG_TAIL = 50;
+export function startDockerLogFollower(containerName, options) {
+    const tail = Math.max(0, options?.tail ?? DEFAULT_DOCKER_LOG_TAIL);
+    const child = spawn('docker', ['logs', '--tail', String(tail), '--follow', containerName], {
+        stdio: 'inherit',
+    });
+    let settled = false;
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    const settle = () => {
+        if (!settled) {
+            settled = true;
+            resolveClosed();
+        }
+    };
+    child.once('error', settle);
+    child.once('close', settle);
+    return {
+        stop: async () => {
+            if (settled) {
+                return;
+            }
+            try {
+                if (!child.kill()) {
+                    settle();
+                }
+            }
+            catch {
+                settle();
+            }
+            await closed;
+        },
+    };
+}

package/dist/lib/env-auth.js

@@ -34,6 +34,9 @@ export function getOauthResource(issuerOrBaseUrl) {
 export function getDefaultOauthScope() {
     return DEFAULT_OAUTH_SCOPE;
 }
+export function getOauthLoopbackRedirectUri(port) {
+    return `http://${LOOPBACK_HOST}:${port}/callback`;
+}
 function formatApiAuthError(prefix, data, fallbackStatus) {
     if (typeof data === 'string' && data.trim()) {
         return `${prefix}: ${data}`;
@@ -629,19 +632,19 @@ async function createLoopbackServer(state) {
         });
         let resolveWaiter;
         let rejectWaiter;
-        const waitForCode = () => new Promise((resolveCode, rejectCode) => {
+        const waitForCode = () => new Promise((resolve, reject) => {
             resolveWaiter = (code) => {
                 void close();
-                resolveCode(code);
+                resolve(code);
             };
             rejectWaiter = (error) => {
                 void close();
-                rejectCode(error);
+                reject(error);
             };
         });
         const close = async () => {
-            await new Promise((resolveClose) => {
-                server.close(() => resolveClose());
+            await new Promise((resolve) => {
+                server.close(() => resolve());
             });
         };
         server.on('error', (error) => {
@@ -655,7 +658,7 @@ async function createLoopbackServer(state) {
                 return;
             }
             resolve({
-                redirectUri: `http://${LOOPBACK_HOST}:${address.port}/callback`,
+                redirectUri: getOauthLoopbackRedirectUri(address.port),
                 waitForCode,
                 close,
             });
@@ -772,7 +775,7 @@ export async function resolveAccessToken(options) {
     }
     const baseUrl = options.baseUrl ?? env.baseUrl;
     if (!baseUrl) {
-        throw new Error(`Env "${envName}" is missing a base URL. Run \`nb env add ${envName} --api-base-url <url>\`.`);
+        throw new Error(`Env "${envName}" is missing a base URL. Update it with \`nb env update ${envName} --api-base-url <url>\` first.`);
     }
     printVerbose(`Refreshing OAuth session for env "${envName}"`);
     return refreshOauthAccessToken({
@@ -793,7 +796,12 @@ export async function resolveServerRequestTarget(options) {
         scope: options.scope,
     });
     if (!baseUrl) {
-        throw new Error('Missing base URL. Use --api-base-url or configure one with `nb env add`.');
+        throw new Error([
+            env ? `Env "${envName}" is missing a base URL.` : `Env "${envName}" is not configured.`,
+            env
+                ? `Use --api-base-url or update env "${envName}" with \`nb env update ${envName} --api-base-url <url>\`.`
+                : `Use --api-base-url or run \`nb init --ui --env ${envName}\` first.`,
+        ].join('\n'));
     }
     return { baseUrl, token };
 }
@@ -807,8 +815,8 @@ export async function authenticateEnvWithBasic(options) {
                 ? `Environment "${envName}" does not have an API base URL yet.`
                 : `Environment "${envName}" has not been set up yet.`,
             env
-                ? `Run \`nb env add ${envName} --api-base-url <url>\` to finish setting it up.`
-                : `Run \`nb env add ${envName}\` first.`,
+                ? `Run \`nb env update ${envName} --api-base-url <url>\` to finish setting it up.`
+                : `Run \`nb init --ui --env ${envName}\` first.`,
         ]
             .filter(Boolean)
             .join('\n'));
@@ -864,8 +872,8 @@ export async function authenticateEnvWithOauth(options) {
                 ? `Environment "${envName}" does not have an API base URL yet.`
                 : `Environment "${envName}" has not been set up yet.`,
             env
-                ? `Run \`nb env add ${envName} --api-base-url <url>\` to finish setting it up.`
-                : `Run \`nb env add ${envName}\` first.`,
+                ? `Run \`nb env update ${envName} --api-base-url <url>\` to finish setting it up.`
+                : `Run \`nb init --ui --env ${envName}\` first.`,
         ]
             .filter(Boolean)
             .join('\n'));
@@ -912,10 +920,13 @@ export async function authenticateEnvWithOauth(options) {
         const code = await new Promise((resolve, reject) => {
             const timeout = setTimeout(() => reject(new Error(`OAuth sign-in timed out after 5 minutes. Run \`nb env auth ${envName}\` to try again.`)), OAUTH_LOGIN_TIMEOUT_MS);
             timeout.unref?.();
-            callback.waitForCode().then((value) => {
+            callback
+                .waitForCode()
+                .then((value) => {
                 clearTimeout(timeout);
                 resolve(value);
-            }, (error) => {
+            })
+                .catch((error) => {
                 clearTimeout(timeout);
                 reject(error);
             });

package/dist/lib/env-command-config.js

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+export const ENV_STRING_CONFIG_FLAG_MAP = {
+    source: 'source',
+    'download-version': 'downloadVersion',
+    'docker-registry': 'dockerRegistry',
+    'docker-platform': 'dockerPlatform',
+    'git-url': 'gitUrl',
+    'npm-registry': 'npmRegistry',
+    'app-path': 'appPath',
+    'app-root-path': 'appRootPath',
+    'storage-path': 'storagePath',
+    'app-public-path': 'appPublicPath',
+    'cdn-base-url': 'cdnBaseUrl',
+    'env-file': 'envFile',
+    'app-port': 'appPort',
+    'app-key': 'appKey',
+    timezone: 'timezone',
+    'db-dialect': 'dbDialect',
+    'builtin-db-image': 'builtinDbImage',
+    'db-host': 'dbHost',
+    'db-port': 'dbPort',
+    'db-database': 'dbDatabase',
+    'db-user': 'dbUser',
+    'db-password': 'dbPassword',
+    'db-schema': 'dbSchema',
+    'db-table-prefix': 'dbTablePrefix',
+    'root-username': 'rootUsername',
+    'root-email': 'rootEmail',
+    'root-password': 'rootPassword',
+    'root-nickname': 'rootNickname',
+};
+export const ENV_BOOLEAN_CONFIG_FLAG_MAP = {
+    'builtin-db': 'builtinDb',
+    'dev-dependencies': 'devDependencies',
+    build: 'build',
+    'build-dts': 'buildDts',
+    'db-underscored': 'dbUnderscored',
+};

package/dist/lib/env-config.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 { resolveAppPublicPath } from './app-public-path.js';
 const STRING_ENV_CONFIG_KEYS = [
     'source',
     'downloadVersion',
@@ -13,8 +14,11 @@ const STRING_ENV_CONFIG_KEYS = [
     'dockerPlatform',
     'gitUrl',
     'npmRegistry',
+    'appPath',
     'appRootPath',
     'storagePath',
+    'appPublicPath',
+    'cdnBaseUrl',
     'envFile',
     'appPort',
     'appKey',
@@ -47,11 +51,12 @@ function trimConfigValue(value) {
 }
 function resolveEnvKind(input) {
     const source = trimConfigValue(input.source);
+    const appPath = trimConfigValue(input.appPath);
     const appRootPath = trimConfigValue(input.appRootPath);
     if (source === 'docker') {
         return 'docker';
     }
-    if (source === 'npm' || source === 'git' || source === 'local' || appRootPath) {
+    if (source === 'npm' || source === 'git' || source === 'local' || appPath || appRootPath) {
         return 'local';
     }
     return 'http';
@@ -64,7 +69,7 @@ export function buildStoredEnvConfig(input) {
     for (const key of STRING_ENV_CONFIG_KEYS) {
         const value = trimConfigValue(input[key]);
         if (value) {
-            envConfig[key] = value;
+            envConfig[key] = key === 'appPublicPath' ? resolveAppPublicPath(value) : value;
         }
     }
     for (const key of BOOLEAN_ENV_CONFIG_KEYS) {

package/dist/lib/env-guard.js

@@ -8,6 +8,7 @@
  */
 import { stdin as input, stdout as output } from 'node:process';
 import { getCurrentEnvName } from './auth-store.js';
+import { translateCli } from './cli-locale.js';
 import { confirm } from "./inquirer.js";
 function normalizeEnvName(value) {
     const text = String(value ?? '').trim();
@@ -23,18 +24,16 @@ function isInteractiveTerminal() {
     return Boolean(input.isTTY && output.isTTY);
 }
 function formatCrossEnvPromptMessage(currentEnv, requestedEnv) {
-    return `Current env is "${currentEnv}", but this command targets "${requestedEnv}" via --env. Continue without switching the current env?`;
+    return translateCli('commands.shared.crossEnv.prompt', {
+        currentEnv,
+        requestedEnv,
+    });
 }
 export function formatCrossEnvRefusalMessage(currentEnv, requestedEnv) {
-    return [
-        `Refusing to run against env "${requestedEnv}" because the current env is "${currentEnv}" and interactive confirmation is unavailable in the current agent session.`,
-        '',
-        'For safety, the agent will not switch envs automatically and will not add --yes on your behalf.',
-        '',
-        'To continue:',
-        `- run \`nb env use ${requestedEnv}\` yourself and then re-run the command, or`,
-        `- re-run the same command with \`--env ${requestedEnv} --yes\` to confirm this one-off cross-env operation.`,
-    ].join('\n');
+    return translateCli('commands.shared.crossEnv.refusal', {
+        currentEnv,
+        requestedEnv,
+    });
 }
 export async function ensureCrossEnvConfirmed(options) {
     const requestedEnv = normalizeEnvName(options.requestedEnv);

package/dist/lib/env-paths.js

@@ -0,0 +1,101 @@
+/**
+ * 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 path from 'node:path';
+import { resolveConfiguredEnvPath } from './cli-home.js';
+function trimPathValue(value) {
+    const text = String(value ?? '').trim();
+    return text || undefined;
+}
+function normalizePathForComparison(value) {
+    return value.replace(/[\\/]+/g, '/').replace(/\/+$/, '');
+}
+export function areConfiguredPathsEquivalent(left, right) {
+    const leftValue = trimPathValue(left);
+    const rightValue = trimPathValue(right);
+    if (!leftValue || !rightValue) {
+        return leftValue === rightValue;
+    }
+    return normalizePathForComparison(leftValue) === normalizePathForComparison(rightValue);
+}
+function trimTrailingSeparators(value) {
+    return value.replace(/[\\/]+$/, '');
+}
+function hasTerminalPathSegment(value, segment) {
+    const normalized = normalizePathForComparison(value);
+    return normalized.endsWith(`/${segment}`) || normalized === segment;
+}
+function dirnameWithTrailingSeparator(value) {
+    const trimmed = trimTrailingSeparators(value);
+    if (!trimmed) {
+        return undefined;
+    }
+    const separatorIndex = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    if (separatorIndex < 0) {
+        return undefined;
+    }
+    return trimmed.slice(0, separatorIndex + 1);
+}
+function inferAppPathFromLegacyConfigValue(value, leaf) {
+    if (!value || !hasTerminalPathSegment(value, leaf)) {
+        return undefined;
+    }
+    return dirnameWithTrailingSeparator(value);
+}
+export function deriveConfiguredSourcePath(appPath) {
+    const base = trimPathValue(appPath);
+    if (!base) {
+        return 'source/';
+    }
+    return `${base.replace(/[\\/]+$/, '')}/source/`;
+}
+export function deriveConfiguredStoragePath(appPath) {
+    const base = trimPathValue(appPath);
+    if (!base) {
+        return 'storage/';
+    }
+    return `${base.replace(/[\\/]+$/, '')}/storage/`;
+}
+export function inferConfiguredAppPathFromLegacyConfig(config) {
+    const explicitAppPath = trimPathValue(config.appPath);
+    if (explicitAppPath) {
+        return explicitAppPath;
+    }
+    const candidates = [
+        inferAppPathFromLegacyConfigValue(trimPathValue(config.appRootPath), 'source'),
+        inferAppPathFromLegacyConfigValue(trimPathValue(config.storagePath), 'storage'),
+    ].filter((value) => Boolean(value));
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const [first] = candidates;
+    if (!first) {
+        return undefined;
+    }
+    return candidates.every((candidate) => areConfiguredPathsEquivalent(candidate, first)) ? first : undefined;
+}
+export function resolveConfiguredAppPath(config, scope) {
+    const configuredAppPath = inferConfiguredAppPathFromLegacyConfig(config);
+    return configuredAppPath ? resolveConfiguredEnvPath(configuredAppPath, scope) : undefined;
+}
+export function resolveConfiguredSourcePath(config, scope) {
+    const legacySourcePath = trimPathValue(config.appRootPath);
+    if (legacySourcePath) {
+        return resolveConfiguredEnvPath(legacySourcePath, scope);
+    }
+    const appPath = resolveConfiguredAppPath(config, scope);
+    return appPath ? path.join(appPath, 'source') : undefined;
+}
+export function resolveConfiguredStoragePath(config, scope) {
+    const legacyStoragePath = trimPathValue(config.storagePath);
+    if (legacyStoragePath) {
+        return resolveConfiguredEnvPath(legacyStoragePath, scope);
+    }
+    const appPath = resolveConfiguredAppPath(config, scope);
+    return appPath ? path.join(appPath, 'storage') : undefined;
+}