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

package/dist/lib/portal-config.js

@@ -6,7 +6,6 @@
  * 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, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { executeApiRequest } from './api-client.js';
 import { translateCli } from './cli-locale.js';
@@ -19,9 +18,10 @@ const UPDATE_PORTAL_OPERATION = {
     bodyRequired: true,
     parameters: [
         {
-            name: 'filterByTk',
-            flagName: 'filterByTk',
+            name: 'filter',
+            flagName: 'filter',
             in: 'query',
+            type: 'object',
             required: true,
         },
     ],
@@ -98,29 +98,15 @@ export function mergePortalConfigIntoOptions(config, currentOptions) {
     }
     return nextOptions;
 }
-export async function readPortalConfig(portalDir) {
-    const configPath = path.join(portalDir, 'portal.config.json');
-    const data = JSON.parse(await readFile(configPath, 'utf-8'));
-    const config = readObject(data);
-    const git = readObject(config.git);
-    return buildPortalConfig({
-        portal: path.basename(portalDir),
-        sourceStorage: trimValue(config.sourceStorage),
-        gitRepo: trimValue(git.repo),
-        gitBranch: trimValue(git.branch),
-        gitPath: trimValue(git.path),
-    });
-}
-export async function writePortalConfig(portalDir, config) {
-    await writeFile(path.join(portalDir, 'portal.config.json'), `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
-}
 export async function syncPortalConfigToRemote(options) {
     const apiRequest = options.apiRequest ?? executeApiRequest;
     const response = await apiRequest({
         cliVersion: options.cliVersion ?? '',
         envName: options.envName,
         flags: {
-            filterByTk: options.portal,
+            filter: {
+                portalName: options.portal,
+            },
             body: JSON.stringify({
                 options: mergePortalConfigIntoOptions(options.config, options.currentOptions),
             }),

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 { resolvePortalAppFromApiBaseUrl, 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,34 +40,49 @@ 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 apiBaseUrl = trimValue(options.env.apiBaseUrl);
-    const storagePath = resolvePortalStoragePath(options.env);
-    const { app } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
-    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.`));
-    }
+    const portalDir = hasPathChange
+        ? resolvePortalSourcePath(portal, options.sourcePath)
+        : resolveSavedPortalSourcePath(options.env, portal) ?? '';
+    const appContext = await resolvePortalAppContext(options);
+    const { app } = appContext;
+    let config;
+    let remoteSynced = false;
     const list = await listPortalWorkspaces({
         env: options.env,
         envName: options.envName,
         cliVersion: options.cliVersion,
         apiRequest: options.apiRequest,
+        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,
@@ -95,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,14 @@ 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 { run, runPnpmCommand } from './run-npm.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';
 const TEMPLATE_COPY_EXCLUDED_NAMES = new Set(['.git', 'node_modules', '.DS_Store']);
@@ -42,6 +45,11 @@ const FIRST_OR_CREATE_PORTAL_OPERATION = {
         },
     ],
 };
+const APP_INFO_OPERATION = {
+    method: 'GET',
+    pathTemplate: '/app:getInfo',
+    parameters: [],
+};
 function trimValue(value) {
     return String(value ?? '').trim();
 }
@@ -319,6 +327,54 @@ export function resolvePortalAppFromApiBaseUrl(apiBaseUrl, appPublicPath) {
         appPublicPath: resolveAppPublicPath(configuredPublicPath || inferredPublicPath),
     };
 }
+function readAppNameFromInfo(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return undefined;
+    }
+    const direct = data.name;
+    if (typeof direct === 'string' && direct.trim()) {
+        return direct.trim();
+    }
+    return readAppNameFromInfo(data.data);
+}
+function isValidPortalAppName(value) {
+    return /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value);
+}
+async function resolvePortalAppFromServer(options) {
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    try {
+        const response = await apiRequest({
+            cliVersion: options.cliVersion ?? '',
+            envName: options.envName,
+            flags: {},
+            operation: APP_INFO_OPERATION,
+        });
+        if (!response.ok) {
+            return undefined;
+        }
+        const appName = readAppNameFromInfo(response.data);
+        return appName && isValidPortalAppName(appName) ? appName : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function resolvePortalAppContext(options) {
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const resolvedApp = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    if (options.env.kind !== 'http') {
+        return {
+            ...resolvedApp,
+            portalBaseApp: resolvedApp.app,
+        };
+    }
+    const serverApp = await resolvePortalAppFromServer(options);
+    return {
+        app: serverApp ?? resolvedApp.app,
+        appPublicPath: resolvedApp.appPublicPath,
+        portalBaseApp: resolvedApp.app,
+    };
+}
 export function buildPortalBasePath(params) {
     const segment = params.app === DEFAULT_PORTAL_APP_NAME
         ? `x/${params.portal}`
@@ -350,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);
@@ -362,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 } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
-    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
-    const portalParentDir = path.join(storagePath, 'portals', app);
-    const portalDir = path.join(portalParentDir, portal);
+    const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
+    const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, 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,
@@ -381,23 +452,32 @@ export async function createPortalWorkspace(options) {
     let shouldCleanupTempDir = true;
     try {
         await copyTemplate(template.dir, tempDir);
+        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 });
         }
         await rename(tempDir, portalDir);
         shouldCleanupTempDir = false;
         const hasPackageJson = await pathExists(path.join(portalDir, 'package.json'));
+        let dependenciesInstalled = false;
+        let installFailed = false;
         if (hasPackageJson) {
             const runCommand = options.runCommand ?? run;
-            await runPnpmCommand(runCommand, ['install'], {
-                cwd: portalDir,
-                env: buildPortalCommandEnv(),
-                envMode: 'replace',
-                errorName: 'pnpm install',
-            });
+            const installCommand = await resolvePnpmInstallCommand(portalDir);
+            try {
+                await runPnpmInstallCommand(runCommand, installCommand.args, {
+                    cwd: portalDir,
+                    env: buildPortalCommandEnv(),
+                    envMode: 'replace',
+                    errorName: installCommand.errorName,
+                });
+                dependenciesInstalled = true;
+            }
+            catch {
+                installFailed = true;
+            }
         }
         else {
             options.onSkipInstall?.(portalCreateText('messages.skipInstall', { portalDir }, `Skipped pnpm install because package.json was not found in ${portalDir}.`));
@@ -421,6 +501,8 @@ export async function createPortalWorkspace(options) {
             portalBase,
             template,
             installSkipped: !hasPackageJson,
+            dependenciesInstalled,
+            installFailed,
             sourceStorage: portalConfig.sourceStorage,
         };
     }

package/dist/lib/portal-deploy.js

@@ -12,11 +12,11 @@ import path from 'node:path';
 import * as tar from 'tar';
 import { executeApiRequest } from './api-client.js';
 import { translateCli } from './cli-locale.js';
-import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, titleFromPortalSlug, validatePortalSlug, } from './portal-create.js';
+import { ensurePortalBuildHtmlReadsEnvOnly } from './portal-build-html.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 { run, runPnpmCommand } from './run-npm.js';
+import { resolvePnpmInstallCommand, run, runPnpmCommand, runPnpmInstallCommand } from './run-npm.js';
 const portalDeployText = (key, values, fallback) => translateCli(`commands.portalDeploy.${key}`, values, { fallback });
 const DEPLOY_OPERATION = {
     method: 'POST',
@@ -106,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);
@@ -173,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,
@@ -192,27 +183,29 @@ async function syncMultiPortalRecord(params) {
 export async function deployPortalWorkspace(options) {
     const portal = validatePortalSlug(options.portal);
     const apiBaseUrl = trimValue(options.env.apiBaseUrl);
-    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);
+    const envApiUrl = resolvePortalEnvApiUrl(apiBaseUrl);
+    const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
+    const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, portal });
+    const deployBase = buildPortalBasePath({ app, appPublicPath, 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,
         portalBase,
     });
+    await ensurePortalBuildHtmlReadsEnvOnly(portalDir);
     const runCommand = options.runCommand ?? run;
-    await runPnpmCommand(runCommand, ['install'], {
+    const installCommand = await resolvePnpmInstallCommand(portalDir);
+    await runPnpmInstallCommand(runCommand, installCommand.args, {
         cwd: portalDir,
         env: buildPortalCommandEnv(),
         envMode: 'replace',
-        errorName: 'pnpm install',
+        errorName: installCommand.errorName,
     });
     await runPnpmCommand(runCommand, ['build'], {
         cwd: portalDir,
@@ -226,39 +219,15 @@ export async function deployPortalWorkspace(options) {
     await runPnpmCommand(runCommand, ['build:html'], {
         cwd: portalDir,
         env: buildPortalCommandEnv({
-            NOCOBASE_API_URL: apiBaseUrl,
+            NOCOBASE_API_URL: envApiUrl,
             NOCOBASE_PORTAL_BASE: portalBase,
         }),
         envMode: 'replace',
         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);
@@ -268,7 +237,7 @@ export async function deployPortalWorkspace(options) {
             archivePath: archive.archivePath,
             app,
             portal,
-            portalBase,
+            portalBase: deployBase,
             envName: options.envName,
             cliVersion: options.cliVersion,
             apiRequest: options.apiRequest,
@@ -279,7 +248,6 @@ export async function deployPortalWorkspace(options) {
     }
     await syncMultiPortalRecord({
         portal,
-        config: portalConfig,
         envName: options.envName,
         cliVersion: options.cliVersion,
         apiRequest: options.apiRequest,
@@ -291,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,23 +10,22 @@ 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, resolvePortalAppFromApiBaseUrl, 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',
     pathTemplate: '/multiPortals:destroy',
     parameters: [
         {
-            name: 'filterByTk',
-            flagName: 'filterByTk',
+            name: 'filter',
+            flagName: 'filter',
             in: 'query',
+            type: 'object',
             required: true,
         },
     ],
 };
-function trimValue(value) {
-    return String(value ?? '').trim();
-}
 async function pathExists(target) {
     try {
         await stat(target);
@@ -48,7 +47,9 @@ async function destroyMultiPortalRecord(params) {
         cliVersion: params.cliVersion ?? '',
         envName: params.envName,
         flags: {
-            filterByTk: params.portal,
+            filter: {
+                portalName: params.portal,
+            },
         },
         operation: DESTROY_PORTAL_OPERATION,
     });
@@ -62,21 +63,29 @@ async function destroyMultiPortalRecord(params) {
 }
 export async function destroyPortalWorkspace(options) {
     const portal = validatePortalSlug(options.portal);
-    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
     const storagePath = resolvePortalStoragePath(options.env);
-    const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
-    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
-    const portalParentDir = path.join(storagePath, 'portals', app);
-    const portalDir = path.join(portalParentDir, portal);
+    const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
+    const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, 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 (!workspaceExists && !options.force) {
-        throw new Error(portalDestroyText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nPass --force to ignore missing local files.`));
+    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,
@@ -85,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, resolvePortalAppFromApiBaseUrl, 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 } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
-    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
-    const portalDir = path.join(storagePath, 'portals', app, portal);
+    const { app, appPublicPath, portalBaseApp } = await resolvePortalAppContext(options);
+    const portalBase = buildPortalBasePath({ app: portalBaseApp ?? app, appPublicPath, 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-env-files.js

@@ -42,8 +42,9 @@ export async function upsertPortalEnvFile(filePath, values) {
     await writeFile(filePath, upsertEnvContent(content, values), 'utf-8');
 }
 export async function updatePortalEnvFiles(params) {
+    const envApiUrl = resolvePortalEnvApiUrl(params.apiBaseUrl);
     await upsertPortalEnvFile(path.join(params.portalDir, '.env'), {
-        NOCOBASE_API_URL: resolvePortalEnvApiUrl(params.apiBaseUrl),
+        NOCOBASE_API_URL: envApiUrl,
         NOCOBASE_PORTAL_BASE: params.portalBase,
     });
     await upsertPortalEnvFile(path.join(params.portalDir, '.env.local'), {