@nocobase/cli 2.2.0-beta.9 → 2.2.0-test.16

package/dist/lib/portal-template.js

@@ -0,0 +1,190 @@
+/**
+ * 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 { cp, mkdir, mkdtemp, rm, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildPortalCommandEnv } from './portal-command-env.js';
+import { resolvePortalTemplate } from './portal-create.js';
+import { run } from './run-npm.js';
+const DEFAULT_PORTAL_APP_NAME = 'main';
+const DEFAULT_PORTAL_NAME = 'admin';
+const PORTAL_CLIENT_PREFIX = 'x';
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function normalizePortalName(value) {
+    const segment = String(value || '')
+        .trim()
+        .replace(/^\/+|\/+$/g, '');
+    return segment || DEFAULT_PORTAL_NAME;
+}
+function normalizePortalAppName(value) {
+    const segment = String(value || '')
+        .trim()
+        .replace(/^\/+|\/+$/g, '');
+    return segment || DEFAULT_PORTAL_APP_NAME;
+}
+function validatePortalSegment(kind, value) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) {
+        throw new Error(`Invalid ${kind} "${value}". Use letters, numbers, underscores, or hyphens, and start with a letter or number.`);
+    }
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveLocalTemplatePath(templateSource) {
+    if (templateSource.startsWith('file://')) {
+        return fileURLToPath(templateSource);
+    }
+    return templateSource;
+}
+function isGitTemplateSource(templateSource) {
+    return (templateSource.startsWith('git@') ||
+        templateSource.startsWith('git+') ||
+        /^https?:\/\//i.test(templateSource) ||
+        templateSource.endsWith('.git'));
+}
+async function getLocalTemplateDir(templateSource) {
+    let localPath;
+    try {
+        localPath = resolveLocalTemplatePath(templateSource);
+    }
+    catch {
+        return undefined;
+    }
+    let result;
+    try {
+        result = await stat(localPath);
+    }
+    catch {
+        return undefined;
+    }
+    if (!result.isDirectory()) {
+        throw new Error(`Portal template "${templateSource}" is invalid: expected a directory.`);
+    }
+    return localPath;
+}
+async function resolveInitialPortalTemplate(params) {
+    const localTemplateDir = await getLocalTemplateDir(params.templateSource);
+    if (localTemplateDir) {
+        return {
+            dir: localTemplateDir,
+            source: params.templateSource,
+            type: 'local',
+        };
+    }
+    if (!isGitTemplateSource(params.templateSource)) {
+        return resolvePortalTemplate(params.templateSource, {
+            npmRegistry: params.npmRegistry,
+            runCommand: params.runCommand,
+        });
+    }
+    await params.runCommand('git', ['clone', '--depth', '1', params.templateSource, params.tempDir], {
+        errorName: 'git clone',
+        stdio: params.verbose ? 'inherit' : 'ignore',
+    });
+    return {
+        dir: params.tempDir,
+        source: params.templateSource,
+        type: 'local',
+    };
+}
+async function copyTemplate(sourceDir, targetDir) {
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, {
+        recursive: true,
+        filter: (source) => !source.split(path.sep).includes('.git'),
+    });
+}
+async function buildPortalHtml(params) {
+    const stdio = params.verbose ? 'inherit' : 'ignore';
+    await params.runCommand('yarn', ['build:html'], {
+        cwd: params.portalDir,
+        env: buildPortalCommandEnv({
+            NOCOBASE_API_URL: '/api',
+            NOCOBASE_PORTAL_BASE: `/${PORTAL_CLIENT_PREFIX}/${params.portalName}/`,
+        }),
+        envMode: 'replace',
+        errorName: 'yarn build:html',
+        stdio,
+    });
+}
+export async function prepareInitialPortalTemplate(options) {
+    const developmentMode = trimValue(options.developmentMode);
+    if (developmentMode !== 'vibe-coding') {
+        return { prepared: false, skippedReason: 'no-code' };
+    }
+    const storagePath = trimValue(options.storagePath);
+    if (!storagePath) {
+        throw new Error('Cannot prepare an initial Portal template without a storage path.');
+    }
+    const templateUrl = trimValue(options.portalTemplate);
+    if (!templateUrl) {
+        throw new Error('Initial Portal template is required when development mode is "vibe-coding".');
+    }
+    const appName = normalizePortalAppName(options.appName);
+    const portalName = normalizePortalName(options.portalName);
+    validatePortalSegment('portal app name', appName);
+    validatePortalSegment('Portal name', portalName);
+    const portalDir = path.join(storagePath, 'portals', appName, portalName);
+    if (await pathExists(portalDir)) {
+        if (await pathExists(path.join(portalDir, 'dist', 'index.html'))) {
+            return { prepared: false, skippedReason: 'already-prepared' };
+        }
+        await rm(portalDir, { recursive: true, force: true });
+    }
+    options.onStartTask?.(`Preparing Portal "${portalName}" from template...`);
+    const runCommand = options.runCommand ?? run;
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-portal-template-'));
+    let cleanupPortalDir = false;
+    let template;
+    try {
+        template = await resolveInitialPortalTemplate({
+            templateSource: templateUrl,
+            tempDir,
+            npmRegistry: options.npmRegistry,
+            verbose: options.verbose,
+            runCommand,
+        });
+        const templateDir = template.dir;
+        if (!(await pathExists(path.join(templateDir, 'package.json')))) {
+            throw new Error(`Portal template "${templateUrl}" is invalid: package.json is missing.`);
+        }
+        cleanupPortalDir = true;
+        await copyTemplate(templateDir, portalDir);
+        await rm(path.join(portalDir, 'node_modules'), { recursive: true, force: true });
+        await buildPortalHtml({
+            portalDir,
+            portalName,
+            verbose: options.verbose,
+            runCommand,
+        });
+        cleanupPortalDir = false;
+        options.onSucceedTask?.(`Portal "${portalName}" is ready.`);
+        return { prepared: true };
+    }
+    catch (error) {
+        if (cleanupPortalDir) {
+            await rm(portalDir, { recursive: true, force: true });
+        }
+        options.onFailTask?.(`Failed to prepare Portal "${portalName}".`);
+        throw error;
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+        await template?.cleanup?.();
+    }
+}

package/dist/lib/prompt-catalog-terminal.js

@@ -11,6 +11,17 @@ import { exit, stdin as stdinStream, stdout as stdoutStream } from 'node:process
 import { createCliTranslate } from "./cli-locale.js";
 import { confirm, select, input, password } from "./inquirer.js";
 import { createPromptCatalogHooks, hasIvKey, isBlankText, isPromptBlockSkipped, mergedBoolean, mergedInteger, mergedPassword, mergedSelect, mergedText, resolvePromptCatalogLocale, resolvePromptText, runPromptFieldValidate, selectOptionValues, tryApplyPreset, } from "./prompt-catalog-core.js";
+function buildPromptComputationSeed(catalog, initialValues) {
+    const catalogKeys = new Set(Object.keys(catalog));
+    const seed = {};
+    for (const [key, value] of Object.entries(initialValues)) {
+        if (catalogKeys.has(key) || value === undefined || value === null) {
+            continue;
+        }
+        seed[key] = value;
+    }
+    return seed;
+}
 function adaptInquirerValidate(validate) {
     if (!validate) {
         return undefined;
@@ -113,14 +124,16 @@ export async function runPromptCatalog(catalog, options = {}) {
     const hooks = createTerminalHooks(locale, options.hooks);
     const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !options.yes);
     const preset = options.values ?? {};
+    const computationSeed = buildPromptComputationSeed(catalog, resolveIv);
     const out = {};
     const renderer = createInquirerRenderer();
     for (const [key, def] of Object.entries(catalog)) {
-        if (isPromptBlockSkipped(def, out)) {
+        const valuesSoFar = { ...computationSeed, ...out };
+        if (isPromptBlockSkipped(def, valuesSoFar)) {
             continue;
         }
         if (tryApplyPreset(key, def, preset, out, hooks, locale)) {
-            const errV = await runPromptFieldValidate(def, out[key], out);
+            const errV = await runPromptFieldValidate(def, out[key], { ...computationSeed, ...out });
             if (errV) {
                 hooks.onMissingNonInteractive(errV);
             }
@@ -135,7 +148,7 @@ export async function runPromptCatalog(catalog, options = {}) {
             continue;
         }
         if (def.type === 'run') {
-            await def.run(out, options.command);
+            await def.run({ ...computationSeed, ...out }, options.command);
             continue;
         }
         if (def.type === 'text') {
@@ -144,18 +157,18 @@ export async function runPromptCatalog(catalog, options = {}) {
                 ? resolvePromptText(def.placeholder, locale)
                 : undefined;
             if (!interactive) {
-                const merged = mergedText(key, def, resolveIv, useYesInitial, out);
+                const merged = mergedText(key, def, resolveIv, useYesInitial, valuesSoFar);
                 if (def.required && isBlankText(merged)) {
                     hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.textRequired', { key }));
                 }
                 out[key] = merged;
-                const errT = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errT = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errT) {
                     hooks.onMissingNonInteractive(errT);
                 }
                 continue;
             }
-            const merged = mergedText(key, def, promptIv, false, out);
+            const merged = mergedText(key, def, promptIv, false, valuesSoFar);
             const raw = await callPrompt(() => renderer.text({
                 message,
                 initialValue: merged,
@@ -168,7 +181,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         return undefined;
                     }
                     const currentValue = typeof value === 'string' ? value : String(value ?? '');
-                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    const result = runPromptFieldValidate(def, currentValue, { ...computationSeed, ...out, [key]: currentValue });
                     return result;
                 },
             }), renderer, hooks);
@@ -180,7 +193,7 @@ export async function runPromptCatalog(catalog, options = {}) {
             if (!interactive) {
                 const b = mergedBoolean(key, def, resolveIv, useYesInitial);
                 out[key] = b;
-                const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                const errB = await runPromptFieldValidate(def, b, { ...computationSeed, ...out, [key]: b });
                 if (errB) {
                     hooks.onMissingNonInteractive(errB);
                 }
@@ -191,7 +204,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                 for (;;) {
                     const raw = await callPrompt(() => renderer.confirm({ message, initialValue: merged }), renderer, hooks);
                     const b = Boolean(raw);
-                    const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                    const errB = await runPromptFieldValidate(def, b, { ...computationSeed, ...out, [key]: b });
                     if (errB) {
                         renderer.error(errB);
                         continue;
@@ -224,7 +237,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         : t('promptCatalog.nonInteractive.selectMissingDefault', { key }));
                 }
                 out[key] = merged;
-                const errS = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errS = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errS) {
                     hooks.onMissingNonInteractive(errS);
                 }
@@ -248,7 +261,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         initialValue: uiInitial,
                     }), renderer, hooks);
                     const picked = raw;
-                    const errS = await runPromptFieldValidate(def, picked, { ...out, [key]: picked });
+                    const errS = await runPromptFieldValidate(def, picked, { ...computationSeed, ...out, [key]: picked });
                     if (errS) {
                         renderer.error(errS);
                         continue;
@@ -269,13 +282,13 @@ export async function runPromptCatalog(catalog, options = {}) {
         if (def.type === 'password') {
             const message = resolvePromptText(def.message, locale, key);
             if (!interactive) {
-                const merged = mergedPassword(key, def, resolveIv, useYesInitial);
+                const merged = mergedPassword(key, def, resolveIv, useYesInitial, valuesSoFar);
                 if (merged === undefined) {
                     if (def.required) {
                         hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequired', { key }));
                     }
                     out[key] = '';
-                    const errPE = await runPromptFieldValidate(def, '', { ...out, [key]: '' });
+                    const errPE = await runPromptFieldValidate(def, '', { ...computationSeed, ...out, [key]: '' });
                     if (errPE) {
                         hooks.onMissingNonInteractive(errPE);
                     }
@@ -285,7 +298,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                     hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequiredNonEmpty', { key }));
                 }
                 out[key] = merged;
-                const errP = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errP = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errP) {
                     hooks.onMissingNonInteractive(errP);
                 }
@@ -302,7 +315,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         return undefined;
                     }
                     const currentValue = typeof value === 'string' ? value : String(value ?? '');
-                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    const result = runPromptFieldValidate(def, currentValue, { ...computationSeed, ...out, [key]: currentValue });
                     return result;
                 },
             }), renderer, hooks);
@@ -322,14 +335,14 @@ export async function runPromptCatalog(catalog, options = {}) {
                     }
                     const z = def.initialValue ?? 0;
                     out[key] = z;
-                    const errI = await runPromptFieldValidate(def, z, { ...out, [key]: z });
+                    const errI = await runPromptFieldValidate(def, z, { ...computationSeed, ...out, [key]: z });
                     if (errI) {
                         hooks.onMissingNonInteractive(errI);
                     }
                     continue;
                 }
                 out[key] = merged;
-                const errI2 = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errI2 = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errI2) {
                     hooks.onMissingNonInteractive(errI2);
                 }
@@ -349,7 +362,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         }
                         if (def.validate) {
                             const z = def.initialValue ?? 0;
-                            return runPromptFieldValidate(def, z, { ...out, [key]: z });
+                            return runPromptFieldValidate(def, z, { ...computationSeed, ...out, [key]: z });
                         }
                         return undefined;
                     }
@@ -360,7 +373,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         return undefined;
                     }
                     const n = Number.parseInt(trimmed, 10);
-                    return runPromptFieldValidate(def, n, { ...out, [key]: n });
+                    return runPromptFieldValidate(def, n, { ...computationSeed, ...out, [key]: n });
                 },
             }), renderer, hooks);
             if (typeof raw === 'string' && raw.trim() === '' && !def.required) {

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

@@ -48,13 +48,24 @@ function isInputBlock(def) {
         def.type === 'password' ||
         def.type === 'integer');
 }
+function buildPromptComputationSeed(catalog, userPreset) {
+    const catalogKeys = new Set(Object.keys(catalog));
+    const seed = {};
+    for (const [key, value] of Object.entries(userPreset)) {
+        if (catalogKeys.has(key) || value === undefined || value === null) {
+            continue;
+        }
+        seed[key] = value;
+    }
+    return seed;
+}
 /**
  * Merges CLI/env **`userPreset`** with catalog block defaults, in the same key order and with the
  * same `hidden` / `run` semantics as {@link isPromptBlockSkipped}, so the web form can prefill
  * and reflow `hidden` fields (e.g. `integer` when `select` changes).
  */
 export function buildWebFormValuesFromCatalog(catalog, userPreset = {}) {
-    const out = {};
+    const out = buildPromptComputationSeed(catalog, userPreset);
     for (const [key, def] of Object.entries(catalog)) {
         if (def.type === 'intro' || def.type === 'outro') {
             continue;
@@ -109,7 +120,7 @@ function defaultValueForInput(key, def, out) {
  * from current raw form data (e.g. after changing `select`). Matches how {@link isPromptBlockSkipped} uses `out` while iterating the catalog.
  */
 export function reflowWebFormState(catalog, raw, userSeed = {}) {
-    const out = {};
+    const out = buildPromptComputationSeed(catalog, userSeed);
     const show = {};
     for (const [key, def] of Object.entries(catalog)) {
         if (def.type === 'intro' || def.type === 'outro') {

package/dist/lib/run-npm.js

@@ -48,6 +48,10 @@ 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,
@@ -61,6 +65,15 @@ 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') {
@@ -146,10 +159,7 @@ export async function run(name, args, options) {
         const child = spawn(command, [...args], {
             stdio,
             cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
+            env: buildProcessEnv(options),
             windowsHide: process.platform === 'win32',
         });
         if (options?.stdio === 'pipe' || shouldTeeInheritedOutput(options)) {
@@ -268,10 +278,7 @@ export async function commandSucceeds(name, args, options) {
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
             cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
+            env: buildProcessEnv(options),
             stdio: 'ignore',
             windowsHide: process.platform === 'win32',
         });
@@ -302,10 +309,7 @@ export async function commandOutput(name, args, options) {
     return await new Promise((resolve, reject) => {
         const child = spawn(command, [...args], {
             cwd,
-            env: {
-                ...process.env,
-                ...options?.env,
-            },
+            env: buildProcessEnv(options),
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: process.platform === 'win32',
         });
@@ -364,10 +368,7 @@ export async function commandOutputViaFile(name, args, options) {
         const result = await new Promise((resolve, reject) => {
             const child = spawn(command, [...args], {
                 cwd,
-                env: {
-                    ...process.env,
-                    ...options?.env,
-                },
+                env: buildProcessEnv(options),
                 stdio: ['ignore', stdoutHandle.fd, stderrHandle.fd],
                 windowsHide: process.platform === 'win32',
             });

package/dist/lib/ui.js

@@ -15,8 +15,35 @@ 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).length;
+    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);
 }
 function pad(value, width) {
     const padding = Math.max(0, width - stringWidth(value));