@nocobase/cli 2.2.0-test.16 → 2.2.1

package/dist/lib/cli-config.js

@@ -34,7 +34,6 @@ export const SUPPORTED_CLI_CONFIG_KEYS = [
     'locale',
     'default-ui-host',
     'default-api-host',
-    'default-portal-template',
     'update.policy',
     'license.pkg-url',
     'docker.network',
@@ -121,10 +120,7 @@ function pruneSettings(config) {
         delete config.settings.locale;
     }
     const init = config.settings?.init;
-    if (init &&
-        !trimValue(init.defaultUiHost) &&
-        !trimValue(init.defaultApiHost) &&
-        !trimValue(init.defaultPortalTemplate)) {
+    if (init && !trimValue(init.defaultUiHost) && !trimValue(init.defaultApiHost)) {
         delete config.settings?.init;
     }
     const update = config.settings?.update;
@@ -185,8 +181,6 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.init?.defaultUiHost);
         case 'default-api-host':
             return trimValue(config.settings?.init?.defaultApiHost);
-        case 'default-portal-template':
-            return trimValue(config.settings?.init?.defaultPortalTemplate);
         case 'update.policy':
             return normalizeCliUpdatePolicy(config.settings?.update?.policy);
         case 'license.pkg-url':
@@ -239,8 +233,6 @@ export function getEffectiveCliConfigValue(config, key) {
             return '127.0.0.1';
         case 'default-api-host':
             return '127.0.0.1';
-        case 'default-portal-template':
-            return explicit ?? '';
         case 'update.policy':
             return explicit ?? DEFAULT_UPDATE_POLICY;
         case 'license.pkg-url':
@@ -385,12 +377,6 @@ export async function setCliConfigValue(key, value, options = {}) {
                 defaultApiHost: normalized,
             };
             break;
-        case 'default-portal-template':
-            config.settings.init = {
-                ...(config.settings.init ?? {}),
-                defaultPortalTemplate: normalized,
-            };
-            break;
         case 'update.policy':
             config.settings.update = {
                 ...(config.settings.update ?? {}),
@@ -526,11 +512,6 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.init.defaultApiHost;
             }
             break;
-        case 'default-portal-template':
-            if (config.settings.init) {
-                delete config.settings.init.defaultPortalTemplate;
-            }
-            break;
         case 'update.policy':
             if (config.settings.update) {
                 delete config.settings.update.policy;

package/dist/lib/env-config.js

@@ -36,9 +36,6 @@ const STRING_ENV_CONFIG_KEYS = [
     'dbSchema',
     'dbTablePrefix',
     'lang',
-    'developmentMode',
-    'portalName',
-    'portalTemplate',
     'rootUsername',
     'rootEmail',
     'rootPassword',

package/dist/lib/env-proxy.js

@@ -23,7 +23,6 @@ const DEFAULT_MODERN_CLIENT_PREFIX = 'v';
 const DEFAULT_API_CLIENT_STORAGE_PREFIX = 'NOCOBASE_';
 const DEFAULT_API_CLIENT_STORAGE_TYPE = 'localStorage';
 const DEFAULT_ESM_CDN_BASE_URL = 'https://esm.sh';
-const PORTAL_CLIENT_PREFIX = 'x';
 const LOCAL_APP_PACKAGE_JSON_PATH = 'node_modules/@nocobase/app/package.json';
 const MANAGED_PROXY_BLOCK_BEGIN = '# BEGIN NocoBase proxy';
 const MANAGED_PROXY_BLOCK_END = '# END NocoBase proxy';
@@ -542,8 +541,6 @@ function buildNginxManagedConfigBlock(context) {
             ]
             : []),
         '',
-        buildNginxPortalLocationBlock(context),
-        '',
         `    location = ${apiBasePathNoTrailingSlash} {`,
         `        return 308 ${context.apiBasePath}$is_args$args;`,
         '    }',
@@ -569,7 +566,7 @@ function buildNginxManagedConfigBlock(context) {
         `        include ${context.snippetsDir}/spa-location.conf;`,
         '    }',
         '',
-        `    location ${context.appPublicPath} {`,
+        `    location ^~ ${context.appPublicPath} {`,
         `        alias ${context.publicDir}/;`,
         `        try_files $uri /index-v1.html =404;`,
         `        include ${context.snippetsDir}/spa-location.conf;`,
@@ -578,65 +575,6 @@ function buildNginxManagedConfigBlock(context) {
         `    ${MANAGED_NGINX_CONFIG_BLOCK_END}`,
     ].join('\n');
 }
-function buildNginxPortalRootPublicPath(appPublicPath) {
-    return appPublicPath === DEFAULT_APP_PUBLIC_PATH
-        ? `/${PORTAL_CLIENT_PREFIX}/`
-        : `${trimTrailingSlash(appPublicPath)}/${PORTAL_CLIENT_PREFIX}/`;
-}
-function buildNginxPortalLocationBlock(context) {
-    const portalBasePath = trimTrailingSlash(buildNginxPortalRootPublicPath(context.appPublicPath));
-    const portalBasePathPattern = escapeRegExp(portalBasePath);
-    return [
-        `    location ^~ ${portalBasePath}/apps/ {`,
-        '        absolute_redirect off;',
-        '',
-        `        if ($uri ~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)$) {`,
-        `            return 308 ${portalBasePath}/apps/$subapp/$portal/$is_args$args;`,
-        '        }',
-        '',
-        `        if ($uri !~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)/(?<portal_path>.*)$) {`,
-        '            return 404;',
-        '        }',
-        '',
-        `        root ${context.storageDir};`,
-        '',
-        '        if ($portal_path = "") {',
-        '            rewrite ^ /portals/$subapp/$portal/dist/index.html break;',
-        '        }',
-        '',
-        '        try_files',
-        '            /portals/$subapp/$portal/dist/$portal_path',
-        '            /portals/$subapp/$portal/dist/$portal_path/',
-        '            /portals/$subapp/$portal/dist/index.html',
-        '            =404;',
-        '    }',
-        '',
-        `    location ^~ ${portalBasePath}/ {`,
-        '        absolute_redirect off;',
-        '',
-        `        if ($uri ~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)$) {`,
-        `            return 308 ${portalBasePath}/$portal/$is_args$args;`,
-        '        }',
-        '',
-        `        if ($uri !~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)/(?<portal_path>.*)$) {`,
-        '            return 404;',
-        '        }',
-        '',
-        `        root ${context.storageDir};`,
-        '',
-        '        if ($portal_path = "") {',
-        '            rewrite ^ /portals/main/$portal/dist/index.html break;',
-        '        }',
-        '',
-        '        try_files',
-        '            /portals/main/$portal/dist/$portal_path',
-        '            /portals/main/$portal/dist/$portal_path/',
-        '            /portals/main/$portal/dist/index.html',
-        '            =404;',
-        '    }',
-        '',
-    ].join('\n');
-}
 function buildNginxRuntimeConfig(context, variant) {
     return {
         __webpack_public_path__: context.cdnBaseUrl,
@@ -670,7 +608,6 @@ async function buildEnvProxyNginxRenderContext(source, options) {
     const mappedPublicDir = await mapProxyPathFromCliRoot(publicDir, options);
     const mappedSnippetsDir = await mapProxyPathFromCliRoot(snippetsDir, options);
     const mappedDistRootDir = await mapProxyPathFromCliRoot(distRootDir, options);
-    const mappedStorageDir = await mapProxyPathFromCliRoot(source.storagePath, options);
     const mappedUploadsDir = await mapProxyPathFromCliRoot(uploadsDir, options);
     const v2PublicPath = `${source.settings.appPublicPath.replace(/\/$/, '')}/${source.settings.modernClientPrefix}/`;
     return {
@@ -695,7 +632,6 @@ async function buildEnvProxyNginxRenderContext(source, options) {
         modernClientPrefix: source.settings.modernClientPrefix,
         proxyHost,
         snippetsDir: mappedSnippetsDir,
-        storageDir: mappedStorageDir,
         uploadsDir: mappedUploadsDir,
         v2PublicPath,
         wsPath: source.settings.wsPath,

package/dist/lib/generated-command.js

@@ -15,12 +15,20 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { Command, Flags } from '@oclif/core';
+import { getCurrentEnvName, getEnv } from './auth-store.js';
 import { executeApiRequest } from './api-client.js';
+import { resolveAppUrlFromApiBaseUrl } from '../commands/env/shared.js';
 import { findApiCommandCompatViolation, formatApiCommandCompatViolation } from './api-command-compat.js';
+import { openUrlInDefaultBrowser } from './browser.js';
 import { ensureCrossEnvConfirmed } from './env-guard.js';
 import { applyPostProcessor } from './post-processors.js';
 import { readInstalledManagedSkillsVersion } from './skills-manager.js';
 import { registerPostProcessors } from '../post-processors/index.js';
+const UI_OPERATION_QUERY_KEY = '_operation_';
+const UI_OPERATION_VERSION = 1;
+function encodeUIOperation(operation) {
+    return Buffer.from(JSON.stringify(operation), 'utf8').toString('base64url');
+}
 function buildParameterFlag(parameter, options) {
     const hints = [parameter.in];
     if (parameter.isFile) {
@@ -104,6 +112,13 @@ export function createGeneratedFlags(operation) {
             required: true,
         });
     }
+    if (operation.ui) {
+        flags.ui = Flags.boolean({
+            description: 'Open the corresponding page in the NocoBase UI',
+            default: false,
+            helpGroup: 'Global',
+        });
+    }
     flags['api-base-url'] = Flags.string({
         description: 'NocoBase API base URL, for example http://localhost:13000/api',
         helpGroup: 'Global',
@@ -142,6 +157,68 @@ export function createGeneratedFlags(operation) {
     });
     return flags;
 }
+function hasFlagValue(value) {
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    return value !== undefined && value !== '';
+}
+function listProvidedBodyFlags(flags, operation) {
+    const rawBodyFlags = ['body', 'body-file'].filter((flagName) => hasFlagValue(flags[flagName])).map((flagName) => `--${flagName}`);
+    const uiParameterNames = new Set(operation.ui?.parameters ?? []);
+    const bodyFieldFlags = operation.parameters
+        .filter((parameter) => parameter.in === 'body' && !uiParameterNames.has(parameter.name) && hasFlagValue(flags[parameter.flagName]))
+        .map((parameter) => `--${parameter.flagName}`);
+    return [...rawBodyFlags, ...bodyFieldFlags];
+}
+async function resolveUiAppUrl(flags) {
+    const apiBaseUrl = typeof flags['api-base-url'] === 'string' ? flags['api-base-url'] : undefined;
+    if (apiBaseUrl) {
+        return resolveAppUrlFromApiBaseUrl(apiBaseUrl);
+    }
+    const requestedEnv = typeof flags.env === 'string' ? flags.env : undefined;
+    const envName = requestedEnv ?? (await getCurrentEnvName());
+    const env = await getEnv(envName);
+    if (!env?.baseUrl) {
+        throw new Error(env
+            ? `Env "${envName}" is missing a base URL. Use --api-base-url or update env "${envName}" with \`nb env update ${envName} --api-base-url <url>\` first.`
+            : `Env "${envName}" is not configured. Use --api-base-url or run \`nb init --ui --env ${envName}\` first.`);
+    }
+    return resolveAppUrlFromApiBaseUrl(env.baseUrl);
+}
+function buildUiOperationUrl(appUrl, path, encodedOperation) {
+    const url = new URL(appUrl);
+    url.pathname = `${url.pathname.replace(/\/+$/, '')}/${path}`;
+    url.searchParams.set(UI_OPERATION_QUERY_KEY, encodedOperation);
+    return url.toString();
+}
+async function openUiOperation(command, operation, flags) {
+    const { operationId, ui } = operation;
+    if (!ui || !operationId) {
+        command.error('This API operation does not support --ui.');
+    }
+    const bodyFlags = listProvidedBodyFlags(flags, operation);
+    if (bodyFlags.length) {
+        command.error('--ui cannot be combined with API request body flags. Remove --ui to submit through the API, or remove the body flags to open the UI.');
+    }
+    const uiParameterNames = new Set(ui.parameters ?? []);
+    const params = Object.fromEntries(operation.parameters
+        .filter((parameter) => uiParameterNames.has(parameter.name) && hasFlagValue(flags[parameter.flagName]))
+        .map((parameter) => [parameter.name, flags[parameter.flagName]]));
+    const uiOperation = {
+        v: UI_OPERATION_VERSION,
+        operationId,
+        ...(Object.keys(params).length ? { params } : {}),
+    };
+    const encodedOperation = encodeUIOperation(uiOperation);
+    const appUrl = await resolveUiAppUrl(flags);
+    const targetUrl = buildUiOperationUrl(appUrl, ui.path, encodedOperation);
+    const opened = await openUrlInDefaultBrowser(targetUrl);
+    command.log(targetUrl);
+    if (!opened) {
+        command.warn('Could not open the default browser. Copy the URL above to continue.');
+    }
+}
 export class GeneratedApiCommand extends Command {
     static operation;
     static runtimeVersion;
@@ -169,6 +246,10 @@ export class GeneratedApiCommand extends Command {
         if (compatViolation) {
             this.error(formatApiCommandCompatViolation(compatViolation));
         }
+        if (flags.ui) {
+            await openUiOperation(this, ctor.operation, flags);
+            return;
+        }
         const response = await executeApiRequest({
             cliVersion,
             skillsVersion,

package/dist/lib/managed-init-env.js

@@ -15,7 +15,7 @@ export function resolveManagedSetupState(value) {
 export function isPreparedSetupState(value) {
     return resolveManagedSetupState(value) === 'prepared';
 }
-export function buildInitAppEnvVarsFromConfig(config, options = {}) {
+export function buildInitAppEnvVarsFromConfig(config) {
     const out = {};
     const put = (key, value) => {
         const text = trimValue(value);
@@ -28,10 +28,5 @@ export function buildInitAppEnvVarsFromConfig(config, options = {}) {
     put('INIT_ROOT_EMAIL', config?.rootEmail);
     put('INIT_ROOT_PASSWORD', config?.rootPassword);
     put('INIT_ROOT_NICKNAME', config?.rootNickname);
-    if (options.includePortal !== false) {
-        put('INIT_DEVELOPMENT_MODE', config?.developmentMode);
-        put('INIT_PORTAL_NAME', config?.portalName);
-        put('INIT_PORTAL_TEMPLATE', config?.portalTemplate);
-    }
     return out;
 }

package/dist/lib/naming.js

@@ -1,6 +1,15 @@
+/**
+ * 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';
 export function toKebabCase(value) {
     return value
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
         .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
         .replace(/[^a-zA-Z0-9]+/g, '-')
         .replace(/-+/g, '-')

package/dist/lib/plugin-import.js

@@ -207,6 +207,29 @@ async function openPluginSource(source, npmRegistry, runFn = run) {
     }
     return await packNpmPluginSource(source, npmRegistry, runFn);
 }
+/**
+ * Locate the directory holding the plugin's `package.json` inside a freshly extracted archive.
+ *
+ * Archives reach us in two shapes: npm-style tarballs (`npm pack`, registry downloads) wrap everything in a single
+ * top-level directory — conventionally `package/` — while NocoBase's own `yarn build <plugin> --tar` writes entries at
+ * the archive root. Extracting with a fixed `strip: 1` would silently discard the root-level files of the latter, so we
+ * extract verbatim and pick the package root here instead. When neither shape matches, return the extract root and let
+ * `readPluginMetadata` report the missing `package.json`.
+ */
+async function resolveArchivePackageRoot(extractRoot) {
+    if (await pathExists(path.join(extractRoot, 'package.json'))) {
+        return extractRoot;
+    }
+    const entries = await fsp.readdir(extractRoot, { withFileTypes: true });
+    const directories = entries.filter((entry) => entry.isDirectory());
+    if (directories.length === 1) {
+        const nestedRoot = path.join(extractRoot, directories[0].name);
+        if (await pathExists(path.join(nestedRoot, 'package.json'))) {
+            return nestedRoot;
+        }
+    }
+    return extractRoot;
+}
 async function readPluginMetadata(extractRoot, sourceLabel) {
     const packageJsonPath = path.join(extractRoot, 'package.json');
     let content;
@@ -241,22 +264,21 @@ export async function importPluginSource(source, options = {}) {
     await fsp.mkdir(storagePluginsPath, { recursive: true });
     const archive = await openPluginSource(normalizedSource, options.npmRegistry, options.runFn);
     const stageDir = await fsp.mkdtemp(path.join(storagePluginsPath, '.nb-plugin-import-'));
-    let stageMoved = false;
     try {
         try {
-            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir, strip: 1 }));
+            await pipeline(archive.stream, createGunzip(), tar.extract({ cwd: stageDir }));
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Failed to extract plugin archive from ${archive.source}: ${message}`);
         }
-        const { packageName, packageVersion } = await readPluginMetadata(stageDir, archive.source);
+        const packageRoot = await resolveArchivePackageRoot(stageDir);
+        const { packageName, packageVersion } = await readPluginMetadata(packageRoot, archive.source);
         const outputDir = resolvePluginOutputDir(storagePluginsPath, packageName);
         const action = (await pathExists(outputDir)) ? 'updated' : 'installed';
         await fsp.mkdir(path.dirname(outputDir), { recursive: true });
         await fsp.rm(outputDir, { recursive: true, force: true });
-        await fsp.rename(stageDir, outputDir);
-        stageMoved = true;
+        await fsp.rename(packageRoot, outputDir);
         return {
             action,
             packageName,
@@ -268,9 +290,9 @@ export async function importPluginSource(source, options = {}) {
         };
     }
     finally {
-        if (!stageMoved) {
-            await fsp.rm(stageDir, { recursive: true, force: true });
-        }
+        // Always removes the staging directory: it is either untouched (failure), or an empty wrapper left behind after the
+        // nested package root was renamed out of it.
+        await fsp.rm(stageDir, { recursive: true, force: true });
         await archive.cleanup();
     }
 }

package/dist/lib/resource-command.js

@@ -41,6 +41,22 @@ function parseObjectFlag(value, flagName) {
     }
     return parsed;
 }
+function parseValuesFlag(value, flagName) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = parseJson(value, flagName);
+    if (!parsed || typeof parsed !== 'object') {
+        throw new Error(`--${flagName} must be a JSON object, or a JSON array of objects to create multiple records`);
+    }
+    if (Array.isArray(parsed)) {
+        const invalidIndex = parsed.findIndex((item) => !item || Array.isArray(item) || typeof item !== 'object');
+        if (invalidIndex !== -1) {
+            throw new Error(`--${flagName} array items must all be JSON objects, but item ${invalidIndex} is not`);
+        }
+    }
+    return parsed;
+}
 function parseJsonArrayFlag(value, flagName) {
     if (value === undefined) {
         return undefined;
@@ -187,7 +203,7 @@ export const createFlags = {
     ...resourceBaseFlags,
     ...resourceAssociationFlags,
     values: Flags.string({
-        description: 'Record values used by create as a JSON object.',
+        description: 'Record values used by create as a JSON object, or a JSON array of objects to create multiple records in one request.',
         required: true,
     }),
     whitelist: Flags.string({
@@ -298,7 +314,7 @@ export function buildGetArgs(flags) {
 export function buildCreateArgs(flags) {
     return {
         ...pickSharedArgs(flags),
-        values: parseObjectFlag(flags.values, 'values'),
+        values: parseValuesFlag(flags.values, 'values'),
         whitelist: parseStringArrayFlags(flags.whitelist, 'whitelist'),
         blacklist: parseStringArrayFlags(flags.blacklist, 'blacklist'),
     };

package/dist/lib/resource-request.js

@@ -1,3 +1,11 @@
+/**
+ * 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 { executeRawApiRequest } from './api-client.js';
 function buildActionUrl(resource, action, sourceId) {
     if (typeof sourceId === 'undefined' || sourceId === null || !resource.includes('.')) {

package/dist/lib/run-npm.js

@@ -48,10 +48,6 @@ const MISSING_COMMAND_SPECS = {
         displayName: 'pnpm',
         configKey: 'bin.pnpm',
     },
-    npm: {
-        displayName: 'npm',
-        configKey: 'bin.npm',
-    },
 };
 const DOCKER_DAEMON_UNAVAILABLE_PATTERNS = [
     /cannot connect to the docker daemon/i,
@@ -65,15 +61,6 @@ async function resolveCommandName(name) {
 function shouldTeeInheritedOutput(options) {
     return options?.stdio === 'inherit' && Boolean(String(process.env.NB_CLI_ACTIVE_LOG_FILE ?? '').trim());
 }
-function buildProcessEnv(options) {
-    if (options?.envMode === 'replace') {
-        return options.env ?? {};
-    }
-    return {
-        ...process.env,
-        ...options?.env,
-    };
-}
 function createMissingCommandError(name, label, error) {
     const code = error && typeof error === 'object' && 'code' in error ? String(error.code) : undefined;
     if (code !== 'ENOENT') {
@@ -159,7 +146,10 @@ export async function run(name, args, options) {
         const child = spawn(command, [...args], {
             stdio,
             cwd,
-            env: buildProcessEnv(options),
+            env: {
+                ...process.env,
+                ...options?.env,
+            },
             windowsHide: process.platform === 'win32',
         });
         if (options?.stdio === 'pipe' || shouldTeeInheritedOutput(options)) {
@@ -278,7 +268,10 @@ export async function commandSucceeds(name, args, options) {
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
             cwd,
-            env: buildProcessEnv(options),
+            env: {
+                ...process.env,
+                ...options?.env,
+            },
             stdio: 'ignore',
             windowsHide: process.platform === 'win32',
         });
@@ -309,7 +302,10 @@ export async function commandOutput(name, args, options) {
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
             cwd,
-            env: buildProcessEnv(options),
+            env: {
+                ...process.env,
+                ...options?.env,
+            },
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: process.platform === 'win32',
         });
@@ -368,7 +364,10 @@ export async function commandOutputViaFile(name, args, options) {
         const result = await new Promise((resolve, reject) => {
             const child = spawn(command, [...args], {
                 cwd,
-                env: buildProcessEnv(options),
+                env: {
+                    ...process.env,
+                    ...options?.env,
+                },
                 stdio: ['ignore', stdoutHandle.fd, stderrHandle.fd],
                 windowsHide: process.platform === 'win32',
             });

package/dist/lib/runtime-generator.js

@@ -18,7 +18,31 @@ import { createHash } from 'node:crypto';
 import { loadBuildConfig } from './build-config.js';
 import { toKebabCase, toLogicalActionName, toLogicalResourceName, toResourceSegments } from './naming.js';
 import { collectOperations } from './openapi.js';
-const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file', 'yes']);
+const RESERVED_FLAG_NAMES = new Set(['api-base-url', 'base-url', 'env', 'token', 'json-output', 'body', 'body-file', 'ui', 'yes']);
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isStringArray = (value) => Array.isArray(value) && value.every((item) => typeof item === 'string' && Boolean(item));
+function getGeneratedUIOperation(operation, parameters) {
+    if (!operation.operationId) {
+        return undefined;
+    }
+    const extension = operation['x-nocobase-cli-ui'];
+    if (!isRecord(extension) || typeof extension.path !== 'string') {
+        return undefined;
+    }
+    const path = extension.path.trim();
+    if (!path || path.startsWith('/') || /[?#]/.test(path) || /^[a-z][a-z\d+.-]*:/i.test(path)) {
+        return undefined;
+    }
+    const mappedParameters = extension.parameters === undefined ? [] : extension.parameters;
+    if (!isStringArray(mappedParameters) || new Set(mappedParameters).size !== mappedParameters.length) {
+        return undefined;
+    }
+    const allowedParameters = new Set(parameters.map((parameter) => parameter.name));
+    if (!mappedParameters.every((parameter) => allowedParameters.has(parameter))) {
+        return undefined;
+    }
+    return { path, parameters: mappedParameters };
+}
 function matchesPattern(value, pattern) {
     if (!value) {
         return false;
@@ -425,6 +449,7 @@ export async function generateRuntime(document, configFile, baseUrl) {
         const parameters = (operation.parameters ?? []).filter(isSupportedParameter).map((parameter) => toGeneratedParameter(parameter, usedFlagNames));
         const bodyParameters = extractBodyParameters(operation.requestBody, usedFlagNames);
         const allParameters = [...parameters, ...bodyParameters];
+        const ui = getGeneratedUIOperation(operation, allParameters);
         const hasBody = Boolean(operation.requestBody && !('$ref' in operation.requestBody));
         const requestContentType = getRequestContentType(operation.requestBody);
         const responseType = getResponseType(operation);
@@ -456,6 +481,8 @@ export async function generateRuntime(document, configFile, baseUrl) {
             resourceDisplayName,
             resourceDescription,
             commandId: segments.join(' '),
+            operationId: operation.operationId,
+            ui,
             method,
             pathTemplate,
             tags: operation.tags,

package/dist/lib/ui.js

@@ -15,35 +15,8 @@ let verboseMode = false;
 let lastStaticTaskMessage;
 let lastStaticTaskAt = 0;
 const STATIC_TASK_UPDATE_THROTTLE_MS = 3_000;
-function isCombiningCodePoint(codePoint) {
-    return ((codePoint >= 0x0300 && codePoint <= 0x036f) ||
-        (codePoint >= 0x1ab0 && codePoint <= 0x1aff) ||
-        (codePoint >= 0x1dc0 && codePoint <= 0x1dff) ||
-        (codePoint >= 0x20d0 && codePoint <= 0x20ff) ||
-        (codePoint >= 0xfe20 && codePoint <= 0xfe2f));
-}
-function isFullWidthCodePoint(codePoint) {
-    return (codePoint >= 0x1100 &&
-        (codePoint <= 0x115f ||
-            codePoint === 0x2329 ||
-            codePoint === 0x232a ||
-            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
-            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
-            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
-            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
-            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
-            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
-            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
-            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
-}
 function stringWidth(value) {
-    return Array.from(value).reduce((width, character) => {
-        const codePoint = character.codePointAt(0);
-        if (!codePoint || codePoint === 0 || codePoint < 32 || isCombiningCodePoint(codePoint)) {
-            return width;
-        }
-        return width + (isFullWidthCodePoint(codePoint) ? 2 : 1);
-    }, 0);
+    return Array.from(value).length;
 }
 function pad(value, width) {
     const padding = Math.max(0, width - stringWidth(value));