@nocobase/cli 3.0.0-alpha.5 → 3.0.0-alpha.6

package/dist/lib/portal-configure.js

@@ -6,43 +6,23 @@
  * 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 { mkdir, stat } from 'node:fs/promises';
-import path from 'node:path';
 import { translateCli } from './cli-locale.js';
-import { resolvePortalAppContext, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
-import { buildPortalConfig, buildPortalConfigFromOptions, readPortalConfig, syncPortalConfigToRemote, writePortalConfig, } from './portal-config.js';
+import { resolvePortalAppContext, resolvePortalSourcePath, resolveSavedPortalSourcePath, validatePortalSlug, } from './portal-create.js';
+import { buildPortalConfig, buildPortalConfigFromOptions, syncPortalConfigToRemote, } from './portal-config.js';
 import { findPortalListItem } from './portal-info.js';
 import { listPortalWorkspaces } from './portal-list.js';
 const portalConfigureText = (key, values, fallback) => translateCli(`commands.portalConfigure.${key}`, values, { fallback });
 function trimValue(value) {
     return String(value ?? '').trim();
 }
-async function pathExists(target) {
-    try {
-        await stat(target);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function hasConfigurationChange(options) {
+function hasSourceConfigurationChange(options) {
     return Boolean(options.sourceStorage !== undefined ||
         trimValue(options.gitRepo) ||
         trimValue(options.gitBranch) ||
         trimValue(options.gitPath));
 }
-async function readExistingConfig(portalDir) {
-    try {
-        return await readPortalConfig(portalDir);
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === 'ENOENT') {
-            return undefined;
-        }
-        throw error;
-    }
+function hasPathConfigurationChange(options) {
+    return Boolean(trimValue(options.sourcePath));
 }
 function buildConfigFromRemoteOptions(params) {
     if (params.options && Object.keys(params.options).length > 0) {
@@ -60,17 +40,19 @@ function buildConfigFromRemoteOptions(params) {
     });
 }
 export async function configurePortalWorkspace(options) {
-    if (!hasConfigurationChange(options)) {
-        throw new Error(portalConfigureText('errors.noChanges', undefined, 'No portal configuration changes were provided. Pass --source-storage or a --git-* flag.'));
+    const hasSourceChange = hasSourceConfigurationChange(options);
+    const hasPathChange = hasPathConfigurationChange(options);
+    if (!hasSourceChange && !hasPathChange) {
+        throw new Error(portalConfigureText('errors.noChanges', undefined, 'No portal configuration changes were provided. Pass --path, --source-storage, or a --git-* flag.'));
     }
     const portal = validatePortalSlug(options.portal);
-    const storagePath = resolvePortalStoragePath(options.env);
+    const portalDir = hasPathChange
+        ? resolvePortalSourcePath(portal, options.sourcePath)
+        : resolveSavedPortalSourcePath(options.env, portal) ?? '';
     const appContext = await resolvePortalAppContext(options);
     const { app } = appContext;
-    const portalDir = path.join(storagePath, 'portals', app, portal);
-    if (!(await pathExists(portalDir))) {
-        throw new Error(portalConfigureText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` or \`nb portal pull ${portal}\` first.`));
-    }
+    let config;
+    let remoteSynced = false;
     const list = await listPortalWorkspaces({
         env: options.env,
         envName: options.envName,
@@ -79,16 +61,28 @@ export async function configurePortalWorkspace(options) {
         appContext,
     });
     const remoteItem = findPortalListItem(list.items, portal);
-    const existingConfig = (await readExistingConfig(portalDir)) ??
-        buildConfigFromRemoteOptions({
+    if (!remoteItem) {
+        throw new Error(portalConfigureText('errors.notFound', { portal }, `Portal "${portal}" was not found. Run \`nb portal list\` to see available portals.`));
+    }
+    if (!hasSourceChange) {
+        return {
+            app,
             portal,
-            options: remoteItem?.options,
-            sourceStorage: remoteItem?.sourceStorage,
-            gitRepo: remoteItem?.gitRepo,
-            gitBranch: remoteItem?.gitBranch,
-            gitPath: remoteItem?.gitPath,
-        });
-    const config = buildPortalConfig({
+            portalDir,
+            config: undefined,
+            remoteSynced: false,
+            pathUpdated: hasPathChange,
+        };
+    }
+    const existingConfig = buildConfigFromRemoteOptions({
+        portal,
+        options: remoteItem.options,
+        sourceStorage: remoteItem.sourceStorage,
+        gitRepo: remoteItem.gitRepo,
+        gitBranch: remoteItem.gitBranch,
+        gitPath: remoteItem.gitPath,
+    });
+    config = buildPortalConfig({
         portal,
         sourceStorage: options.sourceStorage,
         gitRepo: options.gitRepo,
@@ -96,23 +90,21 @@ export async function configurePortalWorkspace(options) {
         gitPath: options.gitPath,
         existingConfig,
     });
-    await mkdir(portalDir, { recursive: true });
-    await writePortalConfig(portalDir, config);
-    if (remoteItem) {
-        await syncPortalConfigToRemote({
-            portal,
-            config,
-            currentOptions: remoteItem.options,
-            envName: options.envName,
-            cliVersion: options.cliVersion,
-            apiRequest: options.apiRequest,
-        });
-    }
+    await syncPortalConfigToRemote({
+        portal,
+        config,
+        currentOptions: remoteItem.options,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    remoteSynced = true;
     return {
         app,
         portal,
         portalDir,
         config,
-        remoteSynced: Boolean(remoteItem),
+        remoteSynced,
+        pathUpdated: hasPathChange,
     };
 }

package/dist/lib/portal-create.js

@@ -17,11 +17,13 @@ import { createGunzip } from 'node:zlib';
 import * as tar from 'tar';
 import { appendAppPublicPath, resolveAppPublicPath } from './app-public-path.js';
 import { executeApiRequest } from './api-client.js';
+import { resolveEnvPortalPath } from './auth-store.js';
 import { resolveEnvRelativePath } from './cli-home.js';
 import { translateCli } from './cli-locale.js';
 import { ensurePortalBuildHtmlReadsEnvOnly } from './portal-build-html.js';
 import { buildPortalCommandEnv } from './portal-command-env.js';
-import { buildPortalConfig, mergePortalConfigIntoOptions, writePortalConfig, } from './portal-config.js';
+import { canReplacePortalDirectory } from './portal-path-safety.js';
+import { buildPortalConfig, mergePortalConfigIntoOptions, } from './portal-config.js';
 import { resolvePnpmInstallCommand, run, runPnpmInstallCommand } from './run-npm.js';
 const DEFAULT_PORTAL_TEMPLATE = '@nocobase/portal-template-default';
 const DEFAULT_PORTAL_APP_NAME = 'main';
@@ -404,6 +406,19 @@ export function resolvePortalStoragePath(env) {
     }
     return path.resolve(process.cwd(), 'storage');
 }
+function resolveAbsolutePath(value) {
+    return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+}
+export function resolvePortalSourcePath(portal, sourcePath) {
+    return resolveAbsolutePath(trimValue(sourcePath) || portal);
+}
+export function resolveSavedPortalSourcePath(env, portal) {
+    const sourcePath = resolveEnvPortalPath(env.config, portal);
+    return sourcePath ? resolveAbsolutePath(sourcePath) : undefined;
+}
+export function resolvePortalDeployPath(params) {
+    return path.join(params.storagePath, 'portals', params.app, params.portal);
+}
 export async function createPortalWorkspace(options) {
     const portal = validatePortalSlug(options.portal);
     const title = trimValue(options.title) || titleFromPortalSlug(portal);
@@ -416,16 +431,18 @@ export async function createPortalWorkspace(options) {
     });
     const apiBaseUrl = trimValue(options.env.apiBaseUrl);
     const envApiUrl = resolvePortalEnvApiUrl(apiBaseUrl);
-    const storagePath = resolvePortalStoragePath(options.env);
     const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
     const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, portal });
-    const portalParentDir = path.join(storagePath, 'portals', app);
-    const portalDir = path.join(portalParentDir, portal);
+    const portalDir = resolvePortalSourcePath(portal, options.sourcePath);
+    const portalParentDir = path.dirname(portalDir);
     assertPortalDirIsInsideParent(portalParentDir, portalDir);
     const targetExists = await pathExists(portalDir);
     if (targetExists && !options.force) {
         throw new Error(portalCreateText('errors.workspaceExists', { portalDir }, `Portal already exists: ${portalDir}\nPass --force to delete it and create a new portal.`));
     }
+    if (targetExists && options.force && !(await canReplacePortalDirectory(portalDir))) {
+        throw new Error(portalCreateText('errors.workspaceNotReplaceable', { portalDir }, `Refusing to replace a non-portal directory: ${portalDir}`));
+    }
     const template = await resolvePortalTemplate(options.template, {
         npmRegistry: trimValue(options.env.config.npmRegistry),
         runCommand: options.runCommand,
@@ -438,7 +455,6 @@ export async function createPortalWorkspace(options) {
         await ensurePortalBuildHtmlReadsEnvOnly(tempDir);
         await writeFile(path.join(tempDir, '.env'), [`NOCOBASE_API_URL=${envApiUrl}`, `NOCOBASE_PORTAL_BASE=${portalBase}`].join('\n') + '\n', 'utf-8');
         await writeFile(path.join(tempDir, '.env.local'), [`NOCOBASE_API_URL=${apiBaseUrl}`, `NOCOBASE_PORTAL_BASE=${portalBase}`].join('\n') + '\n', 'utf-8');
-        await writePortalConfig(tempDir, portalConfig);
         if (targetExists) {
             await rm(portalDir, { recursive: true, force: true });
         }

package/dist/lib/portal-deploy.js

@@ -13,10 +13,9 @@ import * as tar from 'tar';
 import { executeApiRequest } from './api-client.js';
 import { translateCli } from './cli-locale.js';
 import { ensurePortalBuildHtmlReadsEnvOnly } from './portal-build-html.js';
-import { buildPortalBasePath, resolvePortalAppContext, resolvePortalEnvApiUrl, resolvePortalStoragePath, titleFromPortalSlug, validatePortalSlug, } from './portal-create.js';
+import { buildPortalBasePath, resolvePortalAppContext, resolvePortalEnvApiUrl, resolveSavedPortalSourcePath, resolvePortalSourcePath, titleFromPortalSlug, validatePortalSlug, } from './portal-create.js';
 import { buildPortalCommandEnv } from './portal-command-env.js';
 import { updatePortalEnvFiles } from './portal-env-files.js';
-import { mergePortalConfigIntoOptions, readPortalConfig } from './portal-config.js';
 import { resolvePnpmInstallCommand, run, runPnpmCommand, runPnpmInstallCommand } from './run-npm.js';
 const portalDeployText = (key, values, fallback) => translateCli(`commands.portalDeploy.${key}`, values, { fallback });
 const DEPLOY_OPERATION = {
@@ -107,12 +106,6 @@ async function chmodPortalDistTree(targetDir) {
         }
     }));
 }
-async function ensurePortalDistPublicReadable(params) {
-    await chmod(path.join(params.storagePath, 'portals'), PORTAL_PUBLIC_DIR_MODE);
-    await chmod(path.join(params.storagePath, 'portals', params.app), PORTAL_PUBLIC_DIR_MODE);
-    await chmod(params.portalDir, PORTAL_PUBLIC_DIR_MODE);
-    await chmodPortalDistTree(params.distDir);
-}
 async function assertFileExists(filePath, message) {
     try {
         const fileStat = await stat(filePath);
@@ -174,9 +167,6 @@ async function syncMultiPortalRecord(params) {
         uiLayoutUid: DEFAULT_PORTAL_UI_LAYOUT_UID,
         skipCreatePortalDirectory: true,
     };
-    if (params.config) {
-        body.options = mergePortalConfigIntoOptions(params.config);
-    }
     const response = await apiRequest({
         cliVersion: params.cliVersion ?? '',
         envName: params.envName,
@@ -194,17 +184,15 @@ export async function deployPortalWorkspace(options) {
     const portal = validatePortalSlug(options.portal);
     const apiBaseUrl = trimValue(options.env.apiBaseUrl);
     const envApiUrl = resolvePortalEnvApiUrl(apiBaseUrl);
-    const storagePath = resolvePortalStoragePath(options.env);
     const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
     const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, portal });
     const deployBase = buildPortalBasePath({ app, appPublicPath, portal });
-    const portalDir = path.join(storagePath, 'portals', app, portal);
+    const portalDir = resolveSavedPortalSourcePath(options.env, portal) ?? resolvePortalSourcePath(portal);
     const distDir = path.join(portalDir, 'dist');
     if (!(await pathExists(portalDir))) {
         throw new Error(portalDeployText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
     }
     await assertFileExists(path.join(portalDir, 'package.json'), portalDeployText('errors.packageJsonMissing', { portalDir }, `Portal is invalid: package.json is missing in ${portalDir}.`));
-    const portalConfig = await readPortalConfig(portalDir);
     await updatePortalEnvFiles({
         portalDir,
         apiBaseUrl,
@@ -238,32 +226,8 @@ export async function deployPortalWorkspace(options) {
         errorName: 'pnpm build:html',
     });
     await assertFileExists(path.join(distDir, 'index.html'), portalDeployText('errors.distMissing', { distDir }, `Portal build did not produce ${path.join(distDir, 'index.html')}.`));
-    await ensurePortalDistPublicReadable({
-        storagePath,
-        app,
-        portalDir,
-        distDir,
-    });
-    if (options.env.kind === 'local' || options.env.kind === 'docker') {
-        await syncMultiPortalRecord({
-            portal,
-            config: portalConfig,
-            envName: options.envName,
-            cliVersion: options.cliVersion,
-            apiRequest: options.apiRequest,
-        });
-        return {
-            app,
-            portal,
-            portalDir,
-            portalBase,
-            distDir,
-            mode: options.env.kind,
-            uploaded: false,
-            recordSynced: true,
-        };
-    }
-    if (options.env.kind !== 'http') {
+    await chmodPortalDistTree(distDir);
+    if (options.env.kind !== 'local' && options.env.kind !== 'docker' && options.env.kind !== 'http') {
         throw new Error(portalDeployText('errors.unsupportedEnvKind', { kind: options.env.kind }, `Cannot deploy a portal for ${options.env.kind} envs in the first version.`));
     }
     const archive = await packPortalDist(distDir);
@@ -284,7 +248,6 @@ export async function deployPortalWorkspace(options) {
     }
     await syncMultiPortalRecord({
         portal,
-        config: portalConfig,
         envName: options.envName,
         cliVersion: options.cliVersion,
         apiRequest: options.apiRequest,
@@ -296,7 +259,7 @@ export async function deployPortalWorkspace(options) {
         portalBase,
         distDir,
         serverDistPath: uploadResult.distPath,
-        mode: 'http',
+        mode: options.env.kind,
         uploaded: true,
         recordSynced: true,
     };

package/dist/lib/portal-destroy.js

@@ -10,7 +10,8 @@ import { rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { executeApiRequest } from './api-client.js';
 import { translateCli } from './cli-locale.js';
-import { buildPortalBasePath, resolvePortalAppContext, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { isUnsafePortalDeletePath } from './portal-path-safety.js';
+import { buildPortalBasePath, resolvePortalAppContext, resolvePortalDeployPath, resolveSavedPortalSourcePath, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
 const portalDestroyText = (key, values, fallback) => translateCli(`commands.portalDestroy.${key}`, values, { fallback });
 const DESTROY_PORTAL_OPERATION = {
     method: 'POST',
@@ -65,15 +66,27 @@ export async function destroyPortalWorkspace(options) {
     const storagePath = resolvePortalStoragePath(options.env);
     const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
     const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, portal });
-    const portalParentDir = path.join(storagePath, 'portals', app);
-    const portalDir = path.join(portalParentDir, portal);
+    const portalDeployDir = resolvePortalDeployPath({ storagePath, app, portal });
+    const portalDevDir = resolveSavedPortalSourcePath(options.env, portal) ?? '';
     const mode = options.env.kind;
     if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
         throw new Error(portalDestroyText('errors.unsupportedEnvKind', { kind: mode }, `Cannot destroy a portal for ${mode} envs in the first version.`));
     }
     const destroyMode = mode;
-    assertPortalDirIsInsideParent(portalParentDir, portalDir);
-    const workspaceExists = await pathExists(portalDir);
+    if (portalDevDir) {
+        assertPortalDirIsInsideParent(path.dirname(portalDevDir), portalDevDir);
+    }
+    assertPortalDirIsInsideParent(path.dirname(portalDeployDir), portalDeployDir);
+    const developmentPathIsDeploymentPath = portalDevDir
+        ? path.resolve(portalDevDir) === path.resolve(portalDeployDir)
+        : false;
+    const deploymentPathExists = await pathExists(portalDeployDir);
+    const developmentPathExists = options.deleteDevPath && portalDevDir && !developmentPathIsDeploymentPath
+        ? await pathExists(portalDevDir)
+        : false;
+    if (developmentPathExists && (await isUnsafePortalDeletePath(portalDevDir))) {
+        throw new Error(portalDestroyText('errors.unsafeDevelopmentPath', { portalDir: portalDevDir }, `Refusing to delete an unsafe portal development path: ${portalDevDir}`));
+    }
     const recordDeleted = await destroyMultiPortalRecord({
         portal,
         envName: options.envName,
@@ -81,16 +94,21 @@ export async function destroyPortalWorkspace(options) {
         force: options.force,
         apiRequest: options.apiRequest,
     });
-    if (workspaceExists) {
-        await rm(portalDir, { recursive: true, force: true });
+    if (deploymentPathExists) {
+        await rm(portalDeployDir, { recursive: true, force: true });
+    }
+    if (developmentPathExists) {
+        await rm(portalDevDir, { recursive: true, force: true });
     }
     return {
         app,
         portal,
-        portalDir,
+        developmentPath: portalDevDir,
+        deploymentPath: portalDeployDir,
         portalBase,
         mode: destroyMode,
         recordDeleted,
-        workspaceDeleted: workspaceExists,
+        developmentPathDeleted: developmentPathExists || (developmentPathIsDeploymentPath && deploymentPathExists),
+        deploymentPathDeleted: deploymentPathExists,
     };
 }

package/dist/lib/portal-dev.js

@@ -9,7 +9,7 @@
 import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { translateCli } from './cli-locale.js';
-import { buildPortalBasePath, resolvePortalAppContext, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { buildPortalBasePath, resolvePortalAppContext, resolveSavedPortalSourcePath, resolvePortalSourcePath, validatePortalSlug, } from './portal-create.js';
 import { buildPortalCommandEnv } from './portal-command-env.js';
 import { updatePortalEnvFiles } from './portal-env-files.js';
 import { run, runPnpmCommand } from './run-npm.js';
@@ -44,10 +44,9 @@ export async function devPortalWorkspace(options) {
     if (options.env.kind === 'ssh') {
         throw new Error(portalDevText('errors.sshUnsupported', undefined, 'Cannot start a portal in dev mode for ssh envs in the first version.'));
     }
-    const storagePath = resolvePortalStoragePath(options.env);
     const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
     const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, portal });
-    const portalDir = path.join(storagePath, 'portals', app, portal);
+    const portalDir = resolveSavedPortalSourcePath(options.env, portal) ?? resolvePortalSourcePath(portal);
     if (!(await pathExists(portalDir))) {
         throw new Error(portalDevText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
     }

package/dist/lib/portal-info.js

@@ -10,9 +10,6 @@ import { translateCli } from './cli-locale.js';
 import { toPortalOutputItem } from './portal-list.js';
 const portalInfoText = (key, values, fallback) => translateCli(`commands.portalInfo.${key}`, values, { fallback });
 function formatBoolean(value) {
-    if (value === null) {
-        return '';
-    }
     return value ? 'yes' : 'no';
 }
 export function findPortalListItem(items, portal) {
@@ -24,8 +21,8 @@ export function formatPortalInfo(item) {
         `${portalInfoText('fields.name', undefined, 'Name')}: ${outputItem.name}`,
         `${portalInfoText('fields.url', undefined, 'URL')}: ${outputItem.url}`,
         `${portalInfoText('fields.portalType', undefined, 'Portal type')}: ${outputItem.portalType}`,
-        `${portalInfoText('fields.path', undefined, 'Local path')}: ${outputItem.localPath}`,
+        `${portalInfoText('fields.developmentPath', undefined, 'Development path')}: ${outputItem.developmentPath}`,
+        `${portalInfoText('fields.deploymentPath', undefined, 'Deployment path')}: ${outputItem.deploymentPath}`,
         `${portalInfoText('fields.enabled', undefined, 'Enabled')}: ${formatBoolean(outputItem.enabled)}`,
-        `${portalInfoText('fields.localSynced', undefined, 'Local synced')}: ${formatBoolean(outputItem.localSynced)}`,
     ].join('\n');
 }

package/dist/lib/portal-list.js

@@ -6,12 +6,10 @@
  * 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 { stat } from 'node:fs/promises';
-import path from 'node:path';
 import { appendAppPublicPath } from './app-public-path.js';
 import { executeApiRequest } from './api-client.js';
 import { translateCli } from './cli-locale.js';
-import { buildPortalBasePath, resolvePortalAppContext, resolvePortalStoragePath, } from './portal-create.js';
+import { buildPortalBasePath, resolvePortalDeployPath, resolvePortalAppContext, resolveSavedPortalSourcePath, resolvePortalStoragePath, } from './portal-create.js';
 const portalListText = (key, values, fallback) => translateCli(`commands.portalList.${key}`, values, { fallback });
 const LIST_PORTALS_OPERATION = {
     method: 'GET',
@@ -57,15 +55,6 @@ function readListData(data) {
     }
     return readListData(directData);
 }
-async function pathExists(target) {
-    try {
-        await stat(target);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function buildPortalAccessUrl(apiBaseUrl, portalBase) {
     try {
         const baseUrl = new URL(apiBaseUrl);
@@ -134,10 +123,11 @@ export function toPortalOutputItem(item) {
         name: item.portalName,
         url: item.portalUrl,
         portalType: item.portalType,
-        localPath: item.localSynced === true ? item.portalDir : '',
+        developmentPath: item.portalDir,
+        deploymentPath: item.deployDir,
         enabled: item.enabled,
+        isDefault: item.isDefault,
         sourceStorage: item.sourceStorage,
-        localSynced: item.localSynced,
     };
 }
 async function listMultiPortalRecords(params) {
@@ -171,38 +161,41 @@ export async function listPortalWorkspaces(options) {
         cliVersion: options.cliVersion,
         apiRequest: options.apiRequest,
     });
-    const items = await Promise.all(records.map(async (record) => {
+    const items = records.map((record) => {
         const uid = readRecordString(record, 'uid');
         const portalName = readRecordString(record, 'portalName') || uid;
         const routePath = readRecordString(record, 'routePath') || `/${portalName}`;
         const portalType = readRecordString(record, 'portalType');
         const enabled = readRecordBoolean(record, 'enabled');
-        const options = readRecordObject(record, 'options');
-        const git = readRecordObject(options, 'git');
-        const sourceStorage = trimValue(options.sourceStorage) || readRecordString(record, 'sourceStorage') || 'nocobase';
+        const isDefault = readRecordBoolean(record, 'isDefault');
+        const recordOptions = readRecordObject(record, 'options');
+        const git = readRecordObject(recordOptions, 'git');
+        const sourceStorage = trimValue(recordOptions.sourceStorage) || readRecordString(record, 'sourceStorage') || 'nocobase';
         const isAi = portalType === 'ai';
-        const portalDir = isAi ? path.join(storagePath, 'portals', app, portalName) : '';
+        const portalDir = isAi ? resolveSavedPortalSourcePath(options.env, portalName) ?? '' : '';
+        const deployDir = isAi ? resolvePortalDeployPath({ storagePath, app, portal: portalName }) : '';
         return {
             uid,
             portalName,
             routePath,
             portalType,
             enabled,
+            isDefault,
             sourceStorage,
             gitRepo: trimValue(git.repo) || readRecordString(record, 'gitRepo'),
             gitBranch: trimValue(git.branch) || readRecordString(record, 'gitBranch'),
             gitPath: trimValue(git.path) || readRecordString(record, 'gitPath'),
-            sourceRevision: trimValue(options.sourceRevision) || readRecordString(record, 'sourceRevision'),
-            options,
+            sourceRevision: trimValue(recordOptions.sourceRevision) || readRecordString(record, 'sourceRevision'),
+            options: recordOptions,
             portalUrl: enabled
                 ? buildPortalAccessUrl(apiBaseUrl, isAi
                     ? buildPortalBasePath({ app: baseApp, appPublicPath, portal: portalName })
                     : buildNoCodePortalBasePath({ app: baseApp, appPublicPath, routePath }))
                 : '',
             portalDir,
-            localSynced: isAi ? await pathExists(portalDir) : null,
+            deployDir,
         };
-    }));
+    });
     return {
         app,
         mode: listMode,

package/dist/lib/portal-path-safety.js

@@ -0,0 +1,76 @@
+/**
+ * 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 { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+async function resolveExistingPath(target) {
+    const resolved = path.resolve(target);
+    try {
+        return await realpath(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function isSameOrAncestor(candidate, child) {
+    const relative = path.relative(candidate, child);
+    return !relative || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+export async function isUnsafePortalDeletePath(target) {
+    const resolvedTarget = await resolveExistingPath(target);
+    const root = path.parse(resolvedTarget).root;
+    if (resolvedTarget === root) {
+        return true;
+    }
+    const homeDir = await resolveExistingPath(os.homedir());
+    if (resolvedTarget === homeDir) {
+        return true;
+    }
+    const cwd = await resolveExistingPath(process.cwd());
+    return isSameOrAncestor(resolvedTarget, cwd);
+}
+async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isEmptyDirectory(target) {
+    try {
+        return (await readdir(target)).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasNocoBasePackageField(target) {
+    try {
+        const data = JSON.parse(await readFile(path.join(target, 'package.json'), 'utf-8'));
+        return (!!data &&
+            typeof data === 'object' &&
+            !Array.isArray(data) &&
+            Object.prototype.hasOwnProperty.call(data, 'nocobase'));
+    }
+    catch {
+        return false;
+    }
+}
+export async function canReplacePortalDirectory(target) {
+    const resolvedTarget = await resolveExistingPath(target);
+    const root = path.parse(resolvedTarget).root;
+    if (resolvedTarget === root || resolvedTarget === (await resolveExistingPath(os.homedir()))) {
+        return false;
+    }
+    if (!(await isDirectory(resolvedTarget))) {
+        return false;
+    }
+    return (await isEmptyDirectory(resolvedTarget)) || (await hasNocoBasePackageField(resolvedTarget));
+}