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

package/dist/lib/portal-create.js

@@ -0,0 +1,488 @@
+/**
+ * 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 { createReadStream } from 'node:fs';
+import { cp, mkdir, mkdtemp, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { pipeline } from 'node:stream/promises';
+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 { resolveEnvRelativePath } from './cli-home.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalCommandEnv } from './portal-command-env.js';
+import { run } from './run-npm.js';
+const DEFAULT_PORTAL_TEMPLATE = '@nocobase/portal-template-default';
+const DEFAULT_PORTAL_APP_NAME = 'main';
+const TEMPLATE_COPY_EXCLUDED_NAMES = new Set(['.git', 'node_modules', '.DS_Store', 'dist']);
+const NPM_PACK_TIMEOUT_MS = 30_000;
+const portalCreateText = (key, values, fallback) => translateCli(`commands.portalCreate.${key}`, values, { fallback });
+const FIRST_OR_CREATE_PORTAL_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:firstOrCreate',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'filterKeys[]',
+            flagName: 'filterKeys',
+            in: 'query',
+            required: true,
+            isArray: true,
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith('/') ? value : `${value}/`;
+}
+function normalizeUrlPathname(pathname) {
+    const normalized = pathname.replace(/\/+/g, '/');
+    return normalized === '/' ? normalized : normalized.replace(/\/+$/, '');
+}
+function resolveApiBaseUrlPathname(apiBaseUrl) {
+    const normalizedApiBaseUrl = trimValue(apiBaseUrl);
+    try {
+        return normalizeUrlPathname(new URL(normalizedApiBaseUrl).pathname);
+    }
+    catch {
+        const [pathname] = normalizedApiBaseUrl.split(/[?#]/, 1);
+        const withLeadingSlash = pathname?.startsWith('/') ? pathname : `/${pathname || 'api'}`;
+        return normalizeUrlPathname(withLeadingSlash);
+    }
+}
+export function resolvePortalEnvApiUrl(apiBaseUrl) {
+    return resolveApiBaseUrlPathname(apiBaseUrl);
+}
+function decodeAppSegment(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+function safeTempPrefix(parentDir, portal) {
+    return path.join(parentDir, `.${portal}-create-`);
+}
+function assertPortalDirIsInsideParent(parentDir, portalDir) {
+    const relative = path.relative(parentDir, portalDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(portalCreateText('errors.outsideParent', { parentDir, portalDir }, `Refusing to modify a Portal workspace outside ${parentDir}: ${portalDir}`));
+    }
+}
+function shouldCopyTemplateEntry(templateDir, source) {
+    const relative = path.relative(templateDir, source);
+    if (!relative) {
+        return true;
+    }
+    return !relative.split(path.sep).some((segment) => TEMPLATE_COPY_EXCLUDED_NAMES.has(segment));
+}
+async function copyTemplate(sourceDir, targetDir) {
+    await cp(sourceDir, targetDir, {
+        recursive: true,
+        filter: (source) => shouldCopyTemplateEntry(sourceDir, source),
+    });
+}
+function looksLikeLocalTemplateSource(source) {
+    return path.isAbsolute(source) || source.startsWith('./') || source.startsWith('../') || source.startsWith('file://');
+}
+function normalizeNpmRegistry(value) {
+    const text = trimValue(value);
+    return text ? text.replace(/\/+$/, '') : undefined;
+}
+async function resolvePackedTemplateTarball(packRoot, sourceLabel) {
+    const entries = await readdir(packRoot, { withFileTypes: true });
+    const tarballs = entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+        .map((entry) => path.join(packRoot, entry.name))
+        .sort();
+    if (tarballs.length === 1) {
+        return tarballs[0];
+    }
+    if (tarballs.length === 0) {
+        throw new Error(portalCreateText('errors.npmPackNoTarball', { source: sourceLabel }, `npm pack did not produce a local tarball for ${sourceLabel}.`));
+    }
+    throw new Error(portalCreateText('errors.npmPackMultipleTarballs', { source: sourceLabel }, `npm pack produced multiple tarballs for ${sourceLabel}.`));
+}
+async function downloadNpmTemplatePackage(params) {
+    const packRoot = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-template-pack-'));
+    const extractRoot = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-template-extract-'));
+    const args = ['pack', '--silent'];
+    const registry = normalizeNpmRegistry(params.npmRegistry);
+    let shouldCleanupPackRoot = true;
+    let shouldCleanupExtractRoot = true;
+    let stdout = '';
+    let stderr = '';
+    if (registry) {
+        args.push(`--registry=${registry}`);
+    }
+    args.push(params.source);
+    try {
+        await params.runCommand('npm', args, {
+            cwd: packRoot,
+            stdio: 'pipe',
+            errorName: 'npm pack',
+            timeoutMs: NPM_PACK_TIMEOUT_MS,
+            onStdout: (chunk) => {
+                stdout += chunk;
+            },
+            onStderr: (chunk) => {
+                stderr += chunk;
+            },
+        });
+        const tarballPath = await resolvePackedTemplateTarball(packRoot, params.source);
+        try {
+            await pipeline(createReadStream(tarballPath), createGunzip(), tar.extract({ cwd: extractRoot, strip: 1 }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(portalCreateText('errors.templateExtractFailed', { source: params.source, details: message }, `Failed to extract Portal template "${params.source}": ${message}`));
+        }
+        if (!(await pathExists(path.join(extractRoot, 'package.json')))) {
+            throw new Error(portalCreateText('errors.templateMissingPackageJson', { source: params.source }, `Portal template "${params.source}" is invalid: package.json is missing.`));
+        }
+        shouldCleanupPackRoot = false;
+        shouldCleanupExtractRoot = false;
+        return {
+            dir: extractRoot,
+            source: params.source,
+            type: 'package',
+            cleanup: async () => {
+                await rm(packRoot, { recursive: true, force: true });
+                await rm(extractRoot, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        const details = trimValue(stderr) || trimValue(stdout) || (error instanceof Error ? error.message : String(error));
+        throw new Error(portalCreateText('errors.templateDownloadFailed', { source: params.source, details }, `Failed to download Portal template "${params.source}" with npm pack. ${details}`));
+    }
+    finally {
+        if (shouldCleanupPackRoot) {
+            await rm(packRoot, { recursive: true, force: true });
+        }
+        if (shouldCleanupExtractRoot) {
+            await rm(extractRoot, { recursive: true, force: true });
+        }
+    }
+}
+async function resolveLocalTemplateDir(source) {
+    if (source.startsWith('file://')) {
+        const filePath = fileURLToPath(source);
+        if (!(await isDirectory(filePath))) {
+            throw new Error(portalCreateText('errors.templateInvalidDirectory', { source }, `Portal template "${source}" is invalid: expected a directory.`));
+        }
+        return filePath;
+    }
+    const candidate = path.isAbsolute(source) ? source : path.resolve(process.cwd(), source);
+    if (!(await pathExists(candidate))) {
+        return undefined;
+    }
+    if (!(await isDirectory(candidate))) {
+        throw new Error(portalCreateText('errors.templateInvalidDirectory', { source }, `Portal template "${source}" is invalid: expected a directory.`));
+    }
+    return candidate;
+}
+export async function resolvePortalTemplate(source = DEFAULT_PORTAL_TEMPLATE, options = {}) {
+    const normalizedSource = trimValue(source) || DEFAULT_PORTAL_TEMPLATE;
+    const localTemplateDir = await resolveLocalTemplateDir(normalizedSource);
+    if (localTemplateDir) {
+        return {
+            dir: localTemplateDir,
+            source: normalizedSource,
+            type: 'local',
+        };
+    }
+    if (looksLikeLocalTemplateSource(normalizedSource)) {
+        throw new Error(portalCreateText('errors.localTemplateMissing', { source: normalizedSource }, `Portal template directory does not exist: ${normalizedSource}`));
+    }
+    try {
+        const require = createRequire(import.meta.url);
+        const packageJsonPath = require.resolve(path.join(normalizedSource, 'package.json'), {
+            paths: [process.cwd()],
+        });
+        return {
+            dir: path.dirname(packageJsonPath),
+            source: normalizedSource,
+            type: 'package',
+        };
+    }
+    catch (error) {
+        return await downloadNpmTemplatePackage({
+            source: normalizedSource,
+            npmRegistry: options.npmRegistry,
+            runCommand: options.runCommand ?? run,
+        });
+    }
+}
+export function validatePortalSlug(value) {
+    const portal = trimValue(value);
+    if (!/^[a-z0-9][a-z0-9_-]*$/.test(portal)) {
+        throw new Error(portalCreateText('errors.invalidPortalName', { value }, `Invalid Portal name "${value}". Use lowercase letters, numbers, underscores, or hyphens, ` +
+            'and start with a lowercase letter or number.'));
+    }
+    return portal;
+}
+function validatePortalSourceStorage(value) {
+    const sourceStorage = trimValue(value) || 'nocobase';
+    if (sourceStorage === 'nocobase' || sourceStorage === 'git') {
+        return sourceStorage;
+    }
+    throw new Error(portalCreateText('errors.invalidSourceStorage', { value: sourceStorage }, `Invalid source storage "${sourceStorage}". Use "nocobase" or "git".`));
+}
+function isFullGitRemoteUrl(value) {
+    return /^(?:https?:\/\/|ssh:\/\/|git@[^:]+:).+/.test(value);
+}
+function validateGitPath(value) {
+    const gitPath = trimValue(value);
+    if (!gitPath || path.isAbsolute(gitPath) || gitPath.split(/[\\/]+/).includes('..')) {
+        throw new Error(portalCreateText('errors.invalidGitPath', { value }, '--git-path must be a relative path inside the Git repository.'));
+    }
+    return gitPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+}
+function validatePortalSourceOptions(options, portal) {
+    const sourceStorage = validatePortalSourceStorage(options.sourceStorage);
+    const hasGitOption = Boolean(trimValue(options.gitRepo) || trimValue(options.gitBranch) || trimValue(options.gitPath));
+    if (sourceStorage === 'nocobase') {
+        if (hasGitOption) {
+            throw new Error(portalCreateText('errors.gitOptionsForNocobaseStorage', undefined, '--git-repo, --git-branch, and --git-path can only be used with --source-storage git.'));
+        }
+        return { sourceStorage };
+    }
+    const repo = trimValue(options.gitRepo);
+    if (!repo) {
+        throw new Error(portalCreateText('errors.gitRepoRequired', undefined, '--git-repo is required when --source-storage is git.'));
+    }
+    if (!isFullGitRemoteUrl(repo)) {
+        throw new Error(portalCreateText('errors.gitRepoInvalid', undefined, '--git-repo must be a full Git remote URL.'));
+    }
+    return {
+        sourceStorage,
+        git: {
+            repo,
+            branch: trimValue(options.gitBranch) || 'main',
+            path: validateGitPath(options.gitPath ?? portal),
+        },
+    };
+}
+async function syncMultiPortalRecord(params) {
+    const apiRequest = params.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: params.cliVersion ?? '',
+        envName: params.envName,
+        flags: {
+            filterKeys: ['uid'],
+            body: JSON.stringify({
+                uid: params.portal,
+                title: params.title,
+                developmentMode: 'vibe-coding',
+                routeName: params.portal,
+                routePath: `/${params.portal}`,
+                authCheck: true,
+                enabled: true,
+                uiLayoutUid: 'admin-layout-model',
+                skipCreatePortalDirectory: true,
+                options: {
+                    sourceStorage: params.sourceStorage,
+                    git: params.git,
+                },
+            }),
+        },
+        operation: FIRST_OR_CREATE_PORTAL_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalCreateText('errors.recordSyncFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal record sync failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+}
+function validatePortalAppName(value) {
+    const app = trimValue(value);
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(app)) {
+        throw new Error(portalCreateText('errors.invalidPortalAppName', { value }, `Invalid Portal app name "${value}" from apiBaseUrl. Use letters, numbers, underscores, or hyphens, ` +
+            'and start with a letter or number.'));
+    }
+    return app;
+}
+export function titleFromPortalSlug(portal) {
+    return portal
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+export function resolvePortalAppFromApiBaseUrl(apiBaseUrl, appPublicPath) {
+    const normalizedApiBaseUrl = trimValue(apiBaseUrl);
+    if (!normalizedApiBaseUrl) {
+        throw new Error(portalCreateText('errors.missingApiBaseUrl', undefined, 'Cannot create a Portal workspace because the selected env has no apiBaseUrl.'));
+    }
+    const configuredPublicPath = trimValue(appPublicPath);
+    let inferredPublicPath = '/';
+    let app = DEFAULT_PORTAL_APP_NAME;
+    const pathname = resolveApiBaseUrlPathname(normalizedApiBaseUrl);
+    const subappMatch = pathname.match(/^(.*)\/api\/__app\/([^/]+)$/);
+    if (subappMatch) {
+        inferredPublicPath = ensureTrailingSlash(subappMatch[1] || '/');
+        app = validatePortalAppName(decodeAppSegment(subappMatch[2] ?? DEFAULT_PORTAL_APP_NAME) || DEFAULT_PORTAL_APP_NAME);
+    }
+    else {
+        const mainAppMatch = pathname.match(/^(.*)\/api$/);
+        if (mainAppMatch) {
+            inferredPublicPath = ensureTrailingSlash(mainAppMatch[1] || '/');
+        }
+    }
+    return {
+        app,
+        appPublicPath: resolveAppPublicPath(configuredPublicPath || inferredPublicPath),
+    };
+}
+export function buildPortalBasePath(params) {
+    const segment = params.app === DEFAULT_PORTAL_APP_NAME
+        ? `x/${params.portal}`
+        : `x/apps/${params.app}/${params.portal}`;
+    return appendAppPublicPath(params.appPublicPath, segment, { trailingSlash: true });
+}
+export function resolvePortalStoragePath(env) {
+    if (env.kind === 'ssh') {
+        throw new Error(portalCreateText('errors.sshUnsupported', undefined, 'Cannot create a Portal workspace for ssh envs in the first version.'));
+    }
+    if (env.kind === 'http' && !trimValue(env.config.storagePath)) {
+        const envName = trimValue(env.name);
+        if (envName) {
+            return path.join(resolveEnvRelativePath(envName), 'source', 'storage');
+        }
+        const envStoragePath = trimValue(process.env.STORAGE_PATH);
+        if (envStoragePath) {
+            return path.isAbsolute(envStoragePath) ? envStoragePath : path.resolve(process.cwd(), envStoragePath);
+        }
+        return path.resolve(process.cwd(), 'storage');
+    }
+    const storagePath = trimValue(env.storagePath);
+    if (storagePath) {
+        return storagePath;
+    }
+    const envStoragePath = trimValue(process.env.STORAGE_PATH);
+    if (envStoragePath) {
+        return path.isAbsolute(envStoragePath) ? envStoragePath : path.resolve(process.cwd(), envStoragePath);
+    }
+    return path.resolve(process.cwd(), 'storage');
+}
+export async function createPortalWorkspace(options) {
+    const portal = validatePortalSlug(options.portal);
+    const title = trimValue(options.title) || titleFromPortalSlug(portal);
+    const sourceOptions = validatePortalSourceOptions(options, portal);
+    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);
+    assertPortalDirIsInsideParent(portalParentDir, portalDir);
+    const targetExists = await pathExists(portalDir);
+    if (targetExists && !options.force) {
+        throw new Error(portalCreateText('errors.workspaceExists', { portalDir }, `Portal workspace already exists: ${portalDir}\nPass --force to delete it and create a new workspace.`));
+    }
+    const template = await resolvePortalTemplate(options.template, {
+        npmRegistry: trimValue(options.env.config.npmRegistry),
+        runCommand: options.runCommand,
+    });
+    await mkdir(portalParentDir, { recursive: true });
+    const tempDir = await mkdtemp(safeTempPrefix(portalParentDir, portal));
+    let shouldCleanupTempDir = true;
+    try {
+        await copyTemplate(template.dir, tempDir);
+        await writeFile(path.join(tempDir, '.env'), [`NOCOBASE_API_URL=${envApiUrl}`, `NOCOBASE_PORTAL_BASE=${portalBase}`].join('\n') + '\n', 'utf-8');
+        await writeFile(path.join(tempDir, '.env.local'), [`NOCOBASE_API_URL=${apiBaseUrl}`, `NOCOBASE_PORTAL_BASE=${portalBase}`].join('\n') + '\n', 'utf-8');
+        const portalConfig = {
+            schemaVersion: 1,
+            app,
+            name: portal,
+            title,
+            basePath: portalBase,
+            apiBaseUrl,
+            sourceStorage: sourceOptions.sourceStorage,
+            git: sourceOptions.git,
+            template: {
+                type: template.type,
+                source: template.source,
+            },
+            createdBy: 'nb portal create',
+            createdAt: new Date().toISOString(),
+        };
+        await writeFile(path.join(tempDir, 'portal.config.json'), `${JSON.stringify(portalConfig, null, 2)}\n`, 'utf-8');
+        if (targetExists) {
+            await rm(portalDir, { recursive: true, force: true });
+        }
+        await rename(tempDir, portalDir);
+        shouldCleanupTempDir = false;
+        const hasPackageJson = await pathExists(path.join(portalDir, 'package.json'));
+        if (hasPackageJson) {
+            const runCommand = options.runCommand ?? run;
+            await runCommand('pnpm', ['install'], {
+                cwd: portalDir,
+                env: buildPortalCommandEnv(),
+                envMode: 'replace',
+                errorName: 'pnpm install',
+            });
+        }
+        else {
+            options.onSkipInstall?.(portalCreateText('messages.skipInstall', { portalDir }, `Skipped pnpm install because package.json was not found in ${portalDir}.`));
+        }
+        if (options.apiRequest || options.cliVersion !== undefined || options.envName !== undefined) {
+            await syncMultiPortalRecord({
+                portal,
+                title,
+                sourceStorage: sourceOptions.sourceStorage,
+                git: sourceOptions.git,
+                envName: options.envName,
+                cliVersion: options.cliVersion,
+                apiRequest: options.apiRequest,
+            });
+        }
+        return {
+            portalDir,
+            app,
+            portal,
+            title,
+            apiBaseUrl,
+            portalBase,
+            template,
+            installSkipped: !hasPackageJson,
+            sourceStorage: sourceOptions.sourceStorage,
+        };
+    }
+    finally {
+        if (shouldCleanupTempDir) {
+            await rm(tempDir, { recursive: true, force: true });
+        }
+        await template.cleanup?.();
+    }
+}