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

package/dist/lib/browser.js

@@ -0,0 +1,29 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { spawn } from 'node:child_process';
+export async function openUrlInDefaultBrowser(url) {
+    const [command, args, options] = process.platform === 'darwin'
+        ? ['open', [url], { detached: true, stdio: 'ignore' }]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore', windowsHide: true }]
+            : ['xdg-open', [url], { detached: true, stdio: 'ignore' }];
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(command, args, options);
+            child.once('error', () => resolve(false));
+            child.once('spawn', () => {
+                child.unref();
+                resolve(true);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/lib/env-proxy.js

@@ -605,17 +605,30 @@ function buildNginxManagedConfigBlock(context) {
         `    ${MANAGED_NGINX_CONFIG_BLOCK_END}`,
     ].join('\n');
 }
-function buildNginxPortalRootPublicPath(appPublicPath) {
+function buildPortalRootPublicPath(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 portalBasePath = trimTrailingSlash(buildPortalRootPublicPath(context.appPublicPath));
     const portalBasePathPattern = escapeRegExp(portalBasePath);
     return [
+        `    location = ${portalBasePath} {`,
+        '        absolute_redirect off;',
+        `        return 302 ${context.v2PublicPath}$is_args$args;`,
+        '    }',
+        '',
+        `    location = ${portalBasePath}/ {`,
+        '        absolute_redirect off;',
+        `        return 302 ${context.v2PublicPath}$is_args$args;`,
+        '    }',
+        '',
         `    location ^~ ${portalBasePath}/apps/ {`,
         '        absolute_redirect off;',
+        `        if ($uri ~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/?$) {`,
+        `            return 302 ${context.v2PublicPath}apps/$subapp/$is_args$args;`,
+        '        }',
         '',
         `        if ($uri ~ ^${portalBasePathPattern}/apps/(?<subapp>[A-Za-z0-9_-]+)/(?<portal>[A-Za-z0-9_-]+)$) {`,
         `            return 308 ${portalBasePath}/apps/$subapp/$portal/$is_args$args;`,
@@ -640,7 +653,6 @@ function buildNginxPortalLocationBlock(context) {
         '',
         `    location ^~ ${portalBasePath}/ {`,
         '        absolute_redirect off;',
-        '',
         `        if ($uri ~ ^${portalBasePathPattern}/(?<portal>[A-Za-z0-9_-]+)$) {`,
         `            return 308 ${portalBasePath}/$portal/$is_args$args;`,
         '        }',
@@ -1229,6 +1241,7 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
     const apiPathMatcher = toCaddyPathMatcher(context.apiBasePath);
     const appPublicPathNoTrailingSlash = trimTrailingSlash(context.appPublicPath);
     const v2PublicPathNoTrailingSlash = trimTrailingSlash(context.v2PublicPath);
+    const portalBasePath = trimTrailingSlash(buildPortalRootPublicPath(context.appPublicPath));
     const rootRedirectBlock = context.appPublicPath === DEFAULT_APP_PUBLIC_PATH
         ? ''
         : `
@@ -1321,6 +1334,14 @@ function renderCaddyAppTemplate(siteAddress, context, publicDir) {
         `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
         '    }',
         '',
+        `    handle ${portalBasePath} {`,
+        `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
+        '    }',
+        '',
+        `    handle ${portalBasePath}/* {`,
+        `        reverse_proxy ${context.proxyHost}:${context.apiPort}`,
+        '    }',
+        '',
         `    @settingsRoute path_regexp settingsRoute ${settingsRoutePattern}`,
         '    handle @settingsRoute {',
         `        root * ${publicDir}`,

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-env-file.js

@@ -21,9 +21,6 @@ function trimValue(value) {
     const text = String(value ?? '').trim();
     return text || undefined;
 }
-function normalizeEnvFilePath(value) {
-    return value.replace(/\\/g, '/');
-}
 function stripWrappingQuotes(value) {
     if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
         return value
@@ -63,38 +60,39 @@ export function resolveManagedLocalEnvFilePath(runtime) {
     const config = runtime.env.config ?? {};
     const explicitEnvFile = trimValue(config.envFile);
     if (explicitEnvFile) {
-        return normalizeEnvFilePath(resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile);
+        return resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile;
     }
     const configuredAppPath = resolveConfiguredAppPath(config);
     if (configuredAppPath) {
-        return normalizeEnvFilePath(path.join(configuredAppPath, '.env'));
+        return path.join(configuredAppPath, '.env');
     }
     if (path.basename(runtime.projectRoot) === 'source') {
-        return normalizeEnvFilePath(path.resolve(runtime.projectRoot, '..', '.env'));
+        return path.resolve(runtime.projectRoot, '..', '.env');
     }
-    return normalizeEnvFilePath(path.join(runtime.projectRoot, '.env'));
+    return path.join(runtime.projectRoot, '.env');
 }
 export function resolveManagedEnvFilePathFromConfig(envName, config) {
     const kind = config?.kind ?? resolveEnvKind(config);
     if (kind === 'docker') {
-        const filePath = resolveDockerEnvFilePath(envName, config);
-        return filePath ? normalizeEnvFilePath(filePath) : undefined;
+        return resolveDockerEnvFilePath(envName, config);
     }
     if (kind !== 'local') {
         return undefined;
     }
     const explicitEnvFile = trimValue(config?.envFile);
     if (explicitEnvFile) {
-        return normalizeEnvFilePath(resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile);
+        return resolveConfiguredEnvPath(explicitEnvFile) ?? explicitEnvFile;
     }
     const configuredAppPath = resolveConfiguredAppPath(config);
     if (configuredAppPath) {
-        return normalizeEnvFilePath(path.join(configuredAppPath, '.env'));
+        return path.join(configuredAppPath, '.env');
     }
     const configuredAppRootPath = trimValue(config?.appRootPath);
     if (configuredAppRootPath) {
         const appRootPath = resolveConfiguredEnvPath(configuredAppRootPath) ?? configuredAppRootPath;
-        return normalizeEnvFilePath(path.basename(appRootPath) === 'source' ? path.resolve(appRootPath, '..', '.env') : path.join(appRootPath, '.env'));
+        return path.basename(appRootPath) === 'source'
+            ? path.resolve(appRootPath, '..', '.env')
+            : path.join(appRootPath, '.env');
     }
     return undefined;
 }

package/dist/lib/prompt-web-ui.js

@@ -765,11 +765,10 @@ function runPromptCatalogWebUIImpl(options) {
             }
         };
         const servePage = (port) => {
-            const base = `http://${publicHost}:${port}`;
             const formInner = buildPwcFormHtml(catalog, formDefaults, initialShow, pwcStepDefs, 0, pwcNSteps, locale, uiText);
             const wizardClientJson = JSON.stringify({ n: pwcNSteps, stepDefs: pwcStepDefs });
-            const pwcValStepUrl = pwcNSteps > 1 ? JSON.stringify(base + resolveValidateStepPath) : 'null';
-            const pwcValFieldUrl = JSON.stringify(base + resolveValidateFieldPath);
+            const pwcValStepUrl = pwcNSteps > 1 ? JSON.stringify(resolveValidateStepPath) : 'null';
+            const pwcValFieldUrl = JSON.stringify(resolveValidateFieldPath);
             const uiTextJson = JSON.stringify(uiText);
             const pwcShellClass = options.stages && options.stages.length > 0
                 ? 'pwc-shell pwc-shell--stages'
@@ -1493,8 +1492,8 @@ function runPromptCatalogWebUIImpl(options) {
   </div>
   <script>
   (function () {
-    var sub = ${JSON.stringify(base + submitPath)};
-    var ref = ${JSON.stringify(base + reflowPath)};
+    var sub = ${JSON.stringify(submitPath)};
+    var ref = ${JSON.stringify(reflowPath)};
     var pwcValStep = ${pwcValStepUrl};
     var pwcValField = ${pwcValFieldUrl};
     var pwcStepMeta = ${JSON.stringify(PWC_FORM_META_STEP)};

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/cli",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.4",
   "description": "NocoBase Command Line Tool",
   "type": "module",
   "main": "dist/generated/command-registry.js",
@@ -147,5 +147,5 @@
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git"
   },
-  "gitHead": "9899cd799c070c7bd85140148ea5b100b046bdc7"
+  "gitHead": "6658768567378382de758c4e814ac510d688400c"
 }