@nocobase/cli 2.2.0-test.16 → 3.0.0-alpha.1

package/dist/lib/portal-create.js

@@ -20,10 +20,11 @@ import { executeApiRequest } from './api-client.js';
 import { resolveEnvRelativePath } from './cli-home.js';
 import { translateCli } from './cli-locale.js';
 import { buildPortalCommandEnv } from './portal-command-env.js';
+import { buildPortalConfig, mergePortalConfigIntoOptions, writePortalConfig, } from './portal-config.js';
 import { run } from './run-npm.js';
 const DEFAULT_PORTAL_TEMPLATE = '@nocobase/portal-template-default';
 const DEFAULT_PORTAL_APP_NAME = 'main';
-const TEMPLATE_COPY_EXCLUDED_NAMES = new Set(['.git', 'node_modules', '.DS_Store', 'dist']);
+const TEMPLATE_COPY_EXCLUDED_NAMES = new Set(['.git', 'node_modules', '.DS_Store']);
 const NPM_PACK_TIMEOUT_MS = 30_000;
 const portalCreateText = (key, values, fallback) => translateCli(`commands.portalCreate.${key}`, values, { fallback });
 const FIRST_OR_CREATE_PORTAL_OPERATION = {
@@ -96,7 +97,7 @@ function safeTempPrefix(parentDir, portal) {
 function assertPortalDirIsInsideParent(parentDir, portalDir) {
     const relative = path.relative(parentDir, portalDir);
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
-        throw new Error(portalCreateText('errors.outsideParent', { parentDir, portalDir }, `Refusing to modify a Portal workspace outside ${parentDir}: ${portalDir}`));
+        throw new Error(portalCreateText('errors.outsideParent', { parentDir, portalDir }, `Refusing to modify a portal outside ${parentDir}: ${portalDir}`));
     }
 }
 function shouldCopyTemplateEntry(templateDir, source) {
@@ -165,7 +166,7 @@ async function downloadNpmTemplatePackage(params) {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            throw new Error(portalCreateText('errors.templateExtractFailed', { source: params.source, details: message }, `Failed to extract Portal template "${params.source}": ${message}`));
+            throw new Error(portalCreateText('errors.templateExtractFailed', { source: params.source, details: message }, `Failed to extract portal template "${params.source}": ${message}`));
         }
         if (!(await pathExists(path.join(extractRoot, 'package.json')))) {
             throw new Error(portalCreateText('errors.templateMissingPackageJson', { source: params.source }, `Portal template "${params.source}" is invalid: package.json is missing.`));
@@ -184,7 +185,7 @@ async function downloadNpmTemplatePackage(params) {
     }
     catch (error) {
         const details = trimValue(stderr) || trimValue(stdout) || (error instanceof Error ? error.message : String(error));
-        throw new Error(portalCreateText('errors.templateDownloadFailed', { source: params.source, details }, `Failed to download Portal template "${params.source}" with npm pack. ${details}`));
+        throw new Error(portalCreateText('errors.templateDownloadFailed', { source: params.source, details }, `Failed to download portal template "${params.source}" with npm pack. ${details}`));
     }
     finally {
         if (shouldCleanupPackRoot) {
@@ -247,74 +248,29 @@ export async function resolvePortalTemplate(source = DEFAULT_PORTAL_TEMPLATE, op
 export function validatePortalSlug(value) {
     const portal = trimValue(value);
     if (!/^[a-z0-9][a-z0-9_-]*$/.test(portal)) {
-        throw new Error(portalCreateText('errors.invalidPortalName', { value }, `Invalid Portal name "${value}". Use lowercase letters, numbers, underscores, or hyphens, ` +
+        throw new Error(portalCreateText('errors.invalidPortalName', { value }, `Invalid portal name "${value}". Use lowercase letters, numbers, underscores, or hyphens, ` +
             'and start with a lowercase letter or number.'));
     }
     return portal;
 }
-function validatePortalSourceStorage(value) {
-    const sourceStorage = trimValue(value) || 'nocobase';
-    if (sourceStorage === 'nocobase' || sourceStorage === 'git') {
-        return sourceStorage;
-    }
-    throw new Error(portalCreateText('errors.invalidSourceStorage', { value: sourceStorage }, `Invalid source storage "${sourceStorage}". Use "nocobase" or "git".`));
-}
-function isFullGitRemoteUrl(value) {
-    return /^(?:https?:\/\/|ssh:\/\/|git@[^:]+:).+/.test(value);
-}
-function validateGitPath(value) {
-    const gitPath = trimValue(value);
-    if (!gitPath || path.isAbsolute(gitPath) || gitPath.split(/[\\/]+/).includes('..')) {
-        throw new Error(portalCreateText('errors.invalidGitPath', { value }, '--git-path must be a relative path inside the Git repository.'));
-    }
-    return gitPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
-}
-function validatePortalSourceOptions(options, portal) {
-    const sourceStorage = validatePortalSourceStorage(options.sourceStorage);
-    const hasGitOption = Boolean(trimValue(options.gitRepo) || trimValue(options.gitBranch) || trimValue(options.gitPath));
-    if (sourceStorage === 'nocobase') {
-        if (hasGitOption) {
-            throw new Error(portalCreateText('errors.gitOptionsForNocobaseStorage', undefined, '--git-repo, --git-branch, and --git-path can only be used with --source-storage git.'));
-        }
-        return { sourceStorage };
-    }
-    const repo = trimValue(options.gitRepo);
-    if (!repo) {
-        throw new Error(portalCreateText('errors.gitRepoRequired', undefined, '--git-repo is required when --source-storage is git.'));
-    }
-    if (!isFullGitRemoteUrl(repo)) {
-        throw new Error(portalCreateText('errors.gitRepoInvalid', undefined, '--git-repo must be a full Git remote URL.'));
-    }
-    return {
-        sourceStorage,
-        git: {
-            repo,
-            branch: trimValue(options.gitBranch) || 'main',
-            path: validateGitPath(options.gitPath ?? portal),
-        },
-    };
-}
 async function syncMultiPortalRecord(params) {
     const apiRequest = params.apiRequest ?? executeApiRequest;
     const response = await apiRequest({
         cliVersion: params.cliVersion ?? '',
         envName: params.envName,
         flags: {
-            filterKeys: ['uid'],
+            filterKeys: ['portalName'],
             body: JSON.stringify({
                 uid: params.portal,
                 title: params.title,
-                developmentMode: 'vibe-coding',
-                routeName: params.portal,
+                portalType: 'ai',
+                portalName: params.portal,
                 routePath: `/${params.portal}`,
                 authCheck: true,
                 enabled: true,
                 uiLayoutUid: 'admin-layout-model',
                 skipCreatePortalDirectory: true,
-                options: {
-                    sourceStorage: params.sourceStorage,
-                    git: params.git,
-                },
+                options: mergePortalConfigIntoOptions(params.config),
             }),
         },
         operation: FIRST_OR_CREATE_PORTAL_OPERATION,
@@ -326,7 +282,7 @@ async function syncMultiPortalRecord(params) {
 function validatePortalAppName(value) {
     const app = trimValue(value);
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(app)) {
-        throw new Error(portalCreateText('errors.invalidPortalAppName', { value }, `Invalid Portal app name "${value}" from apiBaseUrl. Use letters, numbers, underscores, or hyphens, ` +
+        throw new Error(portalCreateText('errors.invalidPortalAppName', { value }, `Invalid portal app name "${value}" from apiBaseUrl. Use letters, numbers, underscores, or hyphens, ` +
             'and start with a letter or number.'));
     }
     return app;
@@ -341,7 +297,7 @@ export function titleFromPortalSlug(portal) {
 export function resolvePortalAppFromApiBaseUrl(apiBaseUrl, appPublicPath) {
     const normalizedApiBaseUrl = trimValue(apiBaseUrl);
     if (!normalizedApiBaseUrl) {
-        throw new Error(portalCreateText('errors.missingApiBaseUrl', undefined, 'Cannot create a Portal workspace because the selected env has no apiBaseUrl.'));
+        throw new Error(portalCreateText('errors.missingApiBaseUrl', undefined, 'Cannot create a portal because the selected env has no apiBaseUrl.'));
     }
     const configuredPublicPath = trimValue(appPublicPath);
     let inferredPublicPath = '/';
@@ -371,7 +327,7 @@ export function buildPortalBasePath(params) {
 }
 export function resolvePortalStoragePath(env) {
     if (env.kind === 'ssh') {
-        throw new Error(portalCreateText('errors.sshUnsupported', undefined, 'Cannot create a Portal workspace for ssh envs in the first version.'));
+        throw new Error(portalCreateText('errors.sshUnsupported', undefined, 'Cannot create a portal for ssh envs in the first version.'));
     }
     if (env.kind === 'http' && !trimValue(env.config.storagePath)) {
         const envName = trimValue(env.name);
@@ -397,7 +353,13 @@ export function resolvePortalStoragePath(env) {
 export async function createPortalWorkspace(options) {
     const portal = validatePortalSlug(options.portal);
     const title = trimValue(options.title) || titleFromPortalSlug(portal);
-    const sourceOptions = validatePortalSourceOptions(options, portal);
+    const portalConfig = buildPortalConfig({
+        portal,
+        sourceStorage: options.sourceStorage,
+        gitRepo: options.gitRepo,
+        gitBranch: options.gitBranch,
+        gitPath: options.gitPath,
+    });
     const apiBaseUrl = trimValue(options.env.apiBaseUrl);
     const envApiUrl = resolvePortalEnvApiUrl(apiBaseUrl);
     const storagePath = resolvePortalStoragePath(options.env);
@@ -408,7 +370,7 @@ export async function createPortalWorkspace(options) {
     assertPortalDirIsInsideParent(portalParentDir, portalDir);
     const targetExists = await pathExists(portalDir);
     if (targetExists && !options.force) {
-        throw new Error(portalCreateText('errors.workspaceExists', { portalDir }, `Portal workspace already exists: ${portalDir}\nPass --force to delete it and create a new workspace.`));
+        throw new Error(portalCreateText('errors.workspaceExists', { portalDir }, `Portal already exists: ${portalDir}\nPass --force to delete it and create a new portal.`));
     }
     const template = await resolvePortalTemplate(options.template, {
         npmRegistry: trimValue(options.env.config.npmRegistry),
@@ -421,23 +383,7 @@ export async function createPortalWorkspace(options) {
         await copyTemplate(template.dir, 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');
-        const portalConfig = {
-            schemaVersion: 1,
-            app,
-            name: portal,
-            title,
-            basePath: portalBase,
-            apiBaseUrl,
-            sourceStorage: sourceOptions.sourceStorage,
-            git: sourceOptions.git,
-            template: {
-                type: template.type,
-                source: template.source,
-            },
-            createdBy: 'nb portal create',
-            createdAt: new Date().toISOString(),
-        };
-        await writeFile(path.join(tempDir, 'portal.config.json'), `${JSON.stringify(portalConfig, null, 2)}\n`, 'utf-8');
+        await writePortalConfig(tempDir, portalConfig);
         if (targetExists) {
             await rm(portalDir, { recursive: true, force: true });
         }
@@ -460,8 +406,7 @@ export async function createPortalWorkspace(options) {
             await syncMultiPortalRecord({
                 portal,
                 title,
-                sourceStorage: sourceOptions.sourceStorage,
-                git: sourceOptions.git,
+                config: portalConfig,
                 envName: options.envName,
                 cliVersion: options.cliVersion,
                 apiRequest: options.apiRequest,
@@ -476,7 +421,7 @@ export async function createPortalWorkspace(options) {
             portalBase,
             template,
             installSkipped: !hasPackageJson,
-            sourceStorage: sourceOptions.sourceStorage,
+            sourceStorage: portalConfig.sourceStorage,
         };
     }
     finally {

package/dist/lib/portal-deploy.js

@@ -15,6 +15,7 @@ import { translateCli } from './cli-locale.js';
 import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, 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 { run } from './run-npm.js';
 const portalDeployText = (key, values, fallback) => translateCli(`commands.portalDeploy.${key}`, values, { fallback });
 const DEPLOY_OPERATION = {
@@ -161,22 +162,26 @@ async function uploadPortalDist(params) {
 }
 async function syncMultiPortalRecord(params) {
     const apiRequest = params.apiRequest ?? executeApiRequest;
+    const body = {
+        uid: params.portal,
+        title: titleFromPortalSlug(params.portal),
+        portalType: 'ai',
+        portalName: params.portal,
+        routePath: `/${params.portal}`,
+        authCheck: true,
+        enabled: true,
+        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,
         flags: {
-            filterKeys: ['uid'],
-            body: JSON.stringify({
-                uid: params.portal,
-                title: titleFromPortalSlug(params.portal),
-                developmentMode: 'vibe-coding',
-                routeName: params.portal,
-                routePath: `/${params.portal}`,
-                authCheck: true,
-                enabled: true,
-                uiLayoutUid: DEFAULT_PORTAL_UI_LAYOUT_UID,
-                skipCreatePortalDirectory: true,
-            }),
+            filterKeys: ['portalName'],
+            body: JSON.stringify(body),
         },
         operation: FIRST_OR_CREATE_PORTAL_OPERATION,
     });
@@ -193,9 +198,10 @@ export async function deployPortalWorkspace(options) {
     const portalDir = path.join(storagePath, 'portals', app, portal);
     const distDir = path.join(portalDir, 'dist');
     if (!(await pathExists(portalDir))) {
-        throw new Error(portalDeployText('errors.workspaceMissing', { portalDir, portal }, `Portal workspace does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
+        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 workspace is invalid: package.json is missing in ${portalDir}.`));
+    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,
@@ -221,6 +227,7 @@ export async function deployPortalWorkspace(options) {
     if (options.env.kind === 'local' || options.env.kind === 'docker') {
         await syncMultiPortalRecord({
             portal,
+            config: portalConfig,
             envName: options.envName,
             cliVersion: options.cliVersion,
             apiRequest: options.apiRequest,
@@ -237,7 +244,7 @@ export async function deployPortalWorkspace(options) {
         };
     }
     if (options.env.kind !== 'http') {
-        throw new Error(portalDeployText('errors.unsupportedEnvKind', { kind: options.env.kind }, `Cannot deploy a Portal workspace for ${options.env.kind} envs in the first version.`));
+        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);
     let uploadResult;
@@ -257,6 +264,7 @@ export async function deployPortalWorkspace(options) {
     }
     await syncMultiPortalRecord({
         portal,
+        config: portalConfig,
         envName: options.envName,
         cliVersion: options.cliVersion,
         apiRequest: options.apiRequest,

package/dist/lib/portal-destroy.js

@@ -39,7 +39,7 @@ async function pathExists(target) {
 function assertPortalDirIsInsideParent(parentDir, portalDir) {
     const relative = path.relative(parentDir, portalDir);
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
-        throw new Error(portalDestroyText('errors.outsideParent', { parentDir, portalDir }, `Refusing to delete a Portal workspace outside ${parentDir}: ${portalDir}`));
+        throw new Error(portalDestroyText('errors.outsideParent', { parentDir, portalDir }, `Refusing to delete a portal outside ${parentDir}: ${portalDir}`));
     }
 }
 async function destroyMultiPortalRecord(params) {
@@ -70,13 +70,13 @@ export async function destroyPortalWorkspace(options) {
     const portalDir = path.join(portalParentDir, 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 workspace for ${mode} envs in the first version.`));
+        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 (!workspaceExists && !options.force) {
-        throw new Error(portalDestroyText('errors.workspaceMissing', { portalDir, portal }, `Portal workspace does not exist: ${portalDir}\nPass --force to ignore missing local files.`));
+        throw new Error(portalDestroyText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nPass --force to ignore missing local files.`));
     }
     const recordDeleted = await destroyMultiPortalRecord({
         portal,

package/dist/lib/portal-dev.js

@@ -42,16 +42,16 @@ export async function devPortalWorkspace(options) {
     const portal = validatePortalSlug(options.portal);
     const apiBaseUrl = trimValue(options.env.apiBaseUrl);
     if (options.env.kind === 'ssh') {
-        throw new Error(portalDevText('errors.sshUnsupported', undefined, 'Cannot start a Portal workspace in dev mode for ssh envs in the first version.'));
+        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 } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
     const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
     const portalDir = path.join(storagePath, 'portals', app, portal);
     if (!(await pathExists(portalDir))) {
-        throw new Error(portalDevText('errors.workspaceMissing', { portalDir, portal }, `Portal workspace does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
+        throw new Error(portalDevText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` first.`));
     }
-    await assertFileExists(path.join(portalDir, 'package.json'), portalDevText('errors.packageJsonMissing', { portalDir }, `Portal workspace is invalid: package.json is missing in ${portalDir}.`));
+    await assertFileExists(path.join(portalDir, 'package.json'), portalDevText('errors.packageJsonMissing', { portalDir }, `Portal is invalid: package.json is missing in ${portalDir}.`));
     await updatePortalEnvFiles({
         portalDir,
         apiBaseUrl,

package/dist/lib/portal-info.js

@@ -16,14 +16,14 @@ function formatBoolean(value) {
     return value ? 'yes' : 'no';
 }
 export function findPortalListItem(items, portal) {
-    return items.find((item) => item.routeName === portal || item.uid === portal);
+    return items.find((item) => item.portalName === portal || item.uid === portal);
 }
 export function formatPortalInfo(item) {
     const outputItem = toPortalOutputItem(item);
     return [
         `${portalInfoText('fields.name', undefined, 'Name')}: ${outputItem.name}`,
         `${portalInfoText('fields.url', undefined, 'URL')}: ${outputItem.url}`,
-        `${portalInfoText('fields.developmentMode', undefined, 'Development mode')}: ${outputItem.developmentMode}`,
+        `${portalInfoText('fields.portalType', undefined, 'Portal type')}: ${outputItem.portalType}`,
         `${portalInfoText('fields.path', undefined, 'Local path')}: ${outputItem.localPath}`,
         `${portalInfoText('fields.enabled', undefined, 'Enabled')}: ${formatBoolean(outputItem.enabled)}`,
         `${portalInfoText('fields.localSynced', undefined, 'Local synced')}: ${formatBoolean(outputItem.localSynced)}`,

package/dist/lib/portal-list.js

@@ -96,9 +96,18 @@ function stripBasePath(pathname, basePath) {
     }
     return pathValue;
 }
-function normalizeNoCodeRoutePath(routePath, appPublicPath) {
+function normalizeNoCodeRoutePath(routePath, appPublicPath, app) {
     let normalizedRoutePath = normalizeRootPath(routePath);
+    const basePaths = app === 'main'
+        ? []
+        : [
+            appendAppPublicPath(appPublicPath, `v/apps/${app}`, { trailingSlash: false }),
+            appendAppPublicPath(appPublicPath, `x/apps/${app}`, { trailingSlash: false }),
+            `/v/apps/${app}`,
+            `/x/apps/${app}`,
+        ];
     for (const basePath of [
+        ...basePaths,
         appendAppPublicPath(appPublicPath, 'v', { trailingSlash: false }),
         appendAppPublicPath(appPublicPath, 'x', { trailingSlash: false }),
         '/v',
@@ -112,15 +121,19 @@ function buildNoCodePortalBasePath(params) {
     if (isAbsoluteUrl(params.routePath)) {
         return params.routePath;
     }
-    const normalizedRoutePath = normalizeNoCodeRoutePath(params.routePath, params.appPublicPath);
-    const segment = normalizedRoutePath === '/' ? 'v' : `v/${normalizedRoutePath.replace(/^\/+/, '')}`;
+    const normalizedRoutePath = normalizeNoCodeRoutePath(params.routePath, params.appPublicPath, params.app);
+    const routeSegment = normalizedRoutePath.replace(/^\/+/, '');
+    let segment = normalizedRoutePath === '/' ? 'v' : `v/${routeSegment}`;
+    if (params.app !== 'main') {
+        segment = normalizedRoutePath === '/' ? `v/apps/${params.app}` : `v/apps/${params.app}/${routeSegment}`;
+    }
     return appendAppPublicPath(params.appPublicPath, segment, { trailingSlash: normalizedRoutePath === '/' });
 }
 export function toPortalOutputItem(item) {
     return {
-        name: item.routeName,
+        name: item.portalName,
         url: item.portalUrl,
-        developmentMode: item.developmentMode,
+        portalType: item.portalType,
         localPath: item.localSynced === true ? item.portalDir : '',
         enabled: item.enabled,
         sourceStorage: item.sourceStorage,
@@ -134,7 +147,7 @@ async function listMultiPortalRecords(params) {
         envName: params.envName,
         flags: {
             pageSize: 200,
-            sort: ['routeName'],
+            sort: ['portalName'],
         },
         operation: LIST_PORTALS_OPERATION,
     });
@@ -149,7 +162,7 @@ export async function listPortalWorkspaces(options) {
     const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
     const mode = options.env.kind;
     if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
-        throw new Error(portalListText('errors.unsupportedEnvKind', { kind: mode }, `Cannot list Portal workspaces for ${mode} envs in the first version.`));
+        throw new Error(portalListText('errors.unsupportedEnvKind', { kind: mode }, `Cannot list portals for ${mode} envs in the first version.`));
     }
     const listMode = mode;
     const records = await listMultiPortalRecords({
@@ -159,33 +172,34 @@ export async function listPortalWorkspaces(options) {
     });
     const items = await Promise.all(records.map(async (record) => {
         const uid = readRecordString(record, 'uid');
-        const routeName = readRecordString(record, 'routeName') || uid;
-        const routePath = readRecordString(record, 'routePath') || `/${routeName}`;
-        const developmentMode = readRecordString(record, 'developmentMode');
+        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 isVibeCoding = developmentMode === 'vibe-coding';
-        const portalDir = isVibeCoding ? path.join(storagePath, 'portals', app, routeName) : '';
+        const isAi = portalType === 'ai';
+        const portalDir = isAi ? path.join(storagePath, 'portals', app, portalName) : '';
         return {
             uid,
-            routeName,
+            portalName,
             routePath,
-            developmentMode,
+            portalType,
             enabled,
             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,
             portalUrl: enabled
-                ? buildPortalAccessUrl(apiBaseUrl, isVibeCoding
-                    ? buildPortalBasePath({ app, appPublicPath, portal: routeName })
-                    : buildNoCodePortalBasePath({ appPublicPath, routePath }))
+                ? buildPortalAccessUrl(apiBaseUrl, isAi
+                    ? buildPortalBasePath({ app, appPublicPath, portal: portalName })
+                    : buildNoCodePortalBasePath({ app, appPublicPath, routePath }))
                 : '',
             portalDir,
-            localSynced: isVibeCoding ? await pathExists(portalDir) : null,
+            localSynced: isAi ? await pathExists(portalDir) : null,
         };
     }));
     return {