@nocobase/cli 2.3.0-beta.6 → 2.4.0-alpha.2

package/dist/lib/portal-list.js

@@ -0,0 +1,205 @@
+/**
+ * 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 { appendAppPublicPath } from './app-public-path.js';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalBasePath, resolvePortalDeployPath, resolvePortalAppContext, resolveSavedPortalSourcePath, resolvePortalStoragePath, } from './portal-create.js';
+const portalListText = (key, values, fallback) => translateCli(`commands.portalList.${key}`, values, { fallback });
+const LIST_PORTALS_OPERATION = {
+    method: 'GET',
+    pathTemplate: '/multiPortals:list',
+    parameters: [
+        {
+            name: 'pageSize',
+            flagName: 'pageSize',
+            in: 'query',
+            type: 'integer',
+        },
+        {
+            name: 'sort[]',
+            flagName: 'sort',
+            in: 'query',
+            isArray: true,
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function readRecordString(record, key) {
+    return trimValue(record[key]);
+}
+function readRecordBoolean(record, key) {
+    return record[key] === true;
+}
+function readRecordObject(record, key) {
+    const value = record[key];
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function readListData(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return [];
+    }
+    const directData = data.data;
+    if (Array.isArray(directData)) {
+        return directData.filter((item) => (Boolean(item) && typeof item === 'object' && !Array.isArray(item)));
+    }
+    return readListData(directData);
+}
+function buildPortalAccessUrl(apiBaseUrl, portalBase) {
+    try {
+        const baseUrl = new URL(apiBaseUrl);
+        return new URL(portalBase, baseUrl.origin).toString();
+    }
+    catch {
+        return portalBase;
+    }
+}
+function normalizeRootPath(pathname) {
+    const trimmed = pathname.trim();
+    if (!trimmed || trimmed === '/') {
+        return '/';
+    }
+    return `/${trimmed.replace(/^\/+/, '').replace(/\/+$/, '')}`;
+}
+function isAbsoluteUrl(value) {
+    return /^[a-z][a-z\d+\-.]*:\/\//i.test(value) || value.startsWith('//');
+}
+function stripBasePath(pathname, basePath) {
+    const pathValue = normalizeRootPath(pathname);
+    const baseValue = normalizeRootPath(basePath);
+    if (pathValue === baseValue) {
+        return '/';
+    }
+    if (pathValue.startsWith(`${baseValue}/`)) {
+        return pathValue.slice(baseValue.length) || '/';
+    }
+    return pathValue;
+}
+function normalizeNoCodeRoutePath(routePath, appPublicPath, app) {
+    let normalizedRoutePath = normalizeRootPath(routePath);
+    const basePaths = app === 'main'
+        ? []
+        : [
+            appendAppPublicPath(appPublicPath, `v/apps/${app}`, { trailingSlash: false }),
+            appendAppPublicPath(appPublicPath, `x/apps/${app}`, { trailingSlash: false }),
+            `/v/apps/${app}`,
+            `/x/apps/${app}`,
+        ];
+    for (const basePath of [
+        ...basePaths,
+        appendAppPublicPath(appPublicPath, 'v', { trailingSlash: false }),
+        appendAppPublicPath(appPublicPath, 'x', { trailingSlash: false }),
+        '/v',
+        '/x',
+    ]) {
+        normalizedRoutePath = stripBasePath(normalizedRoutePath, basePath);
+    }
+    return normalizedRoutePath;
+}
+function buildNoCodePortalBasePath(params) {
+    if (isAbsoluteUrl(params.routePath)) {
+        return params.routePath;
+    }
+    const normalizedRoutePath = normalizeNoCodeRoutePath(params.routePath, params.appPublicPath, params.app);
+    const routeSegment = normalizedRoutePath.replace(/^\/+/, '');
+    let segment = normalizedRoutePath === '/' ? 'v' : `v/${routeSegment}`;
+    if (params.app !== 'main') {
+        segment = normalizedRoutePath === '/' ? `v/apps/${params.app}` : `v/apps/${params.app}/${routeSegment}`;
+    }
+    return appendAppPublicPath(params.appPublicPath, segment, { trailingSlash: normalizedRoutePath === '/' });
+}
+export function toPortalOutputItem(item) {
+    return {
+        name: item.portalName,
+        url: item.portalUrl,
+        portalType: item.portalType,
+        developmentPath: item.portalDir,
+        deploymentPath: item.deployDir,
+        enabled: item.enabled,
+        isDefault: item.isDefault,
+        sourceStorage: item.sourceStorage,
+    };
+}
+async function listMultiPortalRecords(params) {
+    const apiRequest = params.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: params.cliVersion ?? '',
+        envName: params.envName,
+        flags: {
+            pageSize: 200,
+            sort: ['portalName'],
+        },
+        operation: LIST_PORTALS_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalListText('errors.listFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal list failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+    return readListData(response.data);
+}
+export async function listPortalWorkspaces(options) {
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app, appPublicPath, portalBaseApp } = options.appContext ?? (await resolvePortalAppContext(options));
+    const mode = options.env.kind;
+    const baseApp = portalBaseApp ?? app;
+    if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
+        throw new Error(portalListText('errors.unsupportedEnvKind', { kind: mode }, `Cannot list portals for ${mode} envs in the first version.`));
+    }
+    const listMode = mode;
+    const records = await listMultiPortalRecords({
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const items = records.map((record) => {
+        const uid = readRecordString(record, 'uid');
+        const portalName = readRecordString(record, 'portalName') || uid;
+        const routePath = readRecordString(record, 'routePath') || `/${portalName}`;
+        const portalType = readRecordString(record, 'portalType');
+        const enabled = readRecordBoolean(record, 'enabled');
+        const isDefault = readRecordBoolean(record, 'isDefault');
+        const recordOptions = readRecordObject(record, 'options');
+        const git = readRecordObject(recordOptions, 'git');
+        const sourceStorage = trimValue(recordOptions.sourceStorage) || readRecordString(record, 'sourceStorage') || 'nocobase';
+        const isAi = portalType === 'ai';
+        const portalDir = isAi ? resolveSavedPortalSourcePath(options.env, portalName) ?? '' : '';
+        const deployDir = isAi ? resolvePortalDeployPath({ storagePath, app, portal: portalName }) : '';
+        return {
+            uid,
+            portalName,
+            routePath,
+            portalType,
+            enabled,
+            isDefault,
+            sourceStorage,
+            gitRepo: trimValue(git.repo) || readRecordString(record, 'gitRepo'),
+            gitBranch: trimValue(git.branch) || readRecordString(record, 'gitBranch'),
+            gitPath: trimValue(git.path) || readRecordString(record, 'gitPath'),
+            sourceRevision: trimValue(recordOptions.sourceRevision) || readRecordString(record, 'sourceRevision'),
+            options: recordOptions,
+            portalUrl: enabled
+                ? buildPortalAccessUrl(apiBaseUrl, isAi
+                    ? buildPortalBasePath({ app: baseApp, appPublicPath, portal: portalName })
+                    : buildNoCodePortalBasePath({ app: baseApp, appPublicPath, routePath }))
+                : '',
+            portalDir,
+            deployDir,
+        };
+    });
+    return {
+        app,
+        mode: listMode,
+        storagePath,
+        items,
+    };
+}

package/dist/lib/portal-path-safety.js

@@ -0,0 +1,76 @@
+/**
+ * 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 { readdir, readFile, realpath, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+async function resolveExistingPath(target) {
+    const resolved = path.resolve(target);
+    try {
+        return await realpath(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function isSameOrAncestor(candidate, child) {
+    const relative = path.relative(candidate, child);
+    return !relative || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+export async function isUnsafePortalDeletePath(target) {
+    const resolvedTarget = await resolveExistingPath(target);
+    const root = path.parse(resolvedTarget).root;
+    if (resolvedTarget === root) {
+        return true;
+    }
+    const homeDir = await resolveExistingPath(os.homedir());
+    if (resolvedTarget === homeDir) {
+        return true;
+    }
+    const cwd = await resolveExistingPath(process.cwd());
+    return isSameOrAncestor(resolvedTarget, cwd);
+}
+async function isDirectory(target) {
+    try {
+        return (await stat(target)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function isEmptyDirectory(target) {
+    try {
+        return (await readdir(target)).length === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasNocoBasePackageField(target) {
+    try {
+        const data = JSON.parse(await readFile(path.join(target, 'package.json'), 'utf-8'));
+        return (!!data &&
+            typeof data === 'object' &&
+            !Array.isArray(data) &&
+            Object.prototype.hasOwnProperty.call(data, 'nocobase'));
+    }
+    catch {
+        return false;
+    }
+}
+export async function canReplacePortalDirectory(target) {
+    const resolvedTarget = await resolveExistingPath(target);
+    const root = path.parse(resolvedTarget).root;
+    if (resolvedTarget === root || resolvedTarget === (await resolveExistingPath(os.homedir()))) {
+        return false;
+    }
+    if (!(await isDirectory(resolvedTarget))) {
+        return false;
+    }
+    return (await isEmptyDirectory(resolvedTarget)) || (await hasNocoBasePackageField(resolvedTarget));
+}