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

package/dist/lib/portal-list.js

@@ -0,0 +1,197 @@
+/**
+ * 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 { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { appendAppPublicPath } from './app-public-path.js';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, 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);
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+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) {
+    let normalizedRoutePath = normalizeRootPath(routePath);
+    for (const basePath of [
+        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);
+    const segment = normalizedRoutePath === '/' ? 'v' : `v/${normalizedRoutePath.replace(/^\/+/, '')}`;
+    return appendAppPublicPath(params.appPublicPath, segment, { trailingSlash: normalizedRoutePath === '/' });
+}
+export function toPortalOutputItem(item) {
+    return {
+        name: item.routeName,
+        url: item.portalUrl,
+        developmentMode: item.developmentMode,
+        localPath: item.localSynced === true ? item.portalDir : '',
+        enabled: item.enabled,
+        sourceStorage: item.sourceStorage,
+        localSynced: item.localSynced,
+    };
+}
+async function listMultiPortalRecords(params) {
+    const apiRequest = params.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: params.cliVersion ?? '',
+        envName: params.envName,
+        flags: {
+            pageSize: 200,
+            sort: ['routeName'],
+        },
+        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 } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const mode = options.env.kind;
+    if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
+        throw new Error(portalListText('errors.unsupportedEnvKind', { kind: mode }, `Cannot list Portal workspaces 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 = await Promise.all(records.map(async (record) => {
+        const uid = readRecordString(record, 'uid');
+        const routeName = readRecordString(record, 'routeName') || uid;
+        const routePath = readRecordString(record, 'routePath') || `/${routeName}`;
+        const developmentMode = readRecordString(record, 'developmentMode');
+        const enabled = readRecordBoolean(record, 'enabled');
+        const options = readRecordObject(record, 'options');
+        const git = readRecordObject(options, 'git');
+        const sourceStorage = trimValue(options.sourceStorage) || readRecordString(record, 'sourceStorage') || 'nocobase';
+        const isVibeCoding = developmentMode === 'vibe-coding';
+        const portalDir = isVibeCoding ? path.join(storagePath, 'portals', app, routeName) : '';
+        return {
+            uid,
+            routeName,
+            routePath,
+            developmentMode,
+            enabled,
+            sourceStorage,
+            gitRepo: trimValue(git.repo) || readRecordString(record, 'gitRepo'),
+            gitBranch: trimValue(git.branch) || readRecordString(record, 'gitBranch'),
+            gitPath: trimValue(git.path) || readRecordString(record, 'gitPath'),
+            sourceRevision: trimValue(options.sourceRevision) || readRecordString(record, 'sourceRevision'),
+            portalUrl: enabled
+                ? buildPortalAccessUrl(apiBaseUrl, isVibeCoding
+                    ? buildPortalBasePath({ app, appPublicPath, portal: routeName })
+                    : buildNoCodePortalBasePath({ appPublicPath, routePath }))
+                : '',
+            portalDir,
+            localSynced: isVibeCoding ? await pathExists(portalDir) : null,
+        };
+    }));
+    return {
+        app,
+        mode: listMode,
+        storagePath,
+        items,
+    };
+}

package/dist/lib/portal-source.js

@@ -0,0 +1,416 @@
+/**
+ * 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 { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { cp, mkdir, mkdtemp, readdir, rename, rm, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import * as tar from 'tar';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+import { buildPortalBasePath, resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { listPortalWorkspaces } from './portal-list.js';
+import { findPortalListItem } from './portal-info.js';
+const execFileAsync = promisify(execFile);
+const portalSourceText = (key, values, fallback) => translateCli(`commands.portalSource.${key}`, values, { fallback });
+const PULL_SOURCE_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:pullSource',
+    hasBody: true,
+    bodyRequired: true,
+    responseType: 'binary',
+    parameters: [
+        {
+            name: 'app',
+            flagName: 'app',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'portal',
+            flagName: 'portal',
+            in: 'body',
+            required: true,
+        },
+    ],
+};
+const PUSH_SOURCE_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:pushSource',
+    requestContentType: 'multipart/form-data',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'file',
+            flagName: 'file',
+            in: 'body',
+            required: true,
+            isFile: true,
+        },
+        {
+            name: 'app',
+            flagName: 'app',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'portal',
+            flagName: 'portal',
+            in: 'body',
+            required: true,
+        },
+        {
+            name: 'message',
+            flagName: 'message',
+            in: 'body',
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function shouldPackPortalSourceEntry(entryName) {
+    return !entryName.split('/').some((segment) => ['.git', 'node_modules', 'dist', '.DS_Store'].includes(segment));
+}
+function validatePortalSourceTarEntry(entryPath, entry) {
+    if (path.isAbsolute(entryPath) || entryPath.split(/[\\/]+/).includes('..')) {
+        return false;
+    }
+    const tarEntry = entry;
+    if (tarEntry.type === 'SymbolicLink' || tarEntry.type === 'Link' || typeof tarEntry.linkpath === 'string') {
+        return false;
+    }
+    return shouldPackPortalSourceEntry(entryPath);
+}
+async function packPortalSource(portalDir) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-source-'));
+    const archivePath = path.join(tempDir, 'source.tar.gz');
+    const entries = (await readdir(portalDir)).filter(shouldPackPortalSourceEntry);
+    await tar.create({
+        cwd: portalDir,
+        file: archivePath,
+        gzip: true,
+        filter: (entryPath, entry) => validatePortalSourceTarEntry(entryPath, entry),
+    }, entries);
+    return {
+        archivePath,
+        cleanup: async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+}
+async function replacePortalSourceFromArchive(params) {
+    const targetExists = await pathExists(params.portalDir);
+    if (targetExists && !params.force) {
+        throw new Error(portalSourceText('errors.workspaceExists', { portalDir: params.portalDir }, `Portal workspace already exists: ${params.portalDir}\nPass --force to delete it and pull again.`));
+    }
+    const parentDir = path.dirname(params.portalDir);
+    const tempDir = await mkdtemp(path.join(parentDir, `.${path.basename(params.portalDir)}-pull-`));
+    try {
+        await tar.extract({
+            file: params.archivePath,
+            cwd: tempDir,
+            strict: true,
+            filter: validatePortalSourceTarEntry,
+        });
+        if (targetExists) {
+            await rm(params.portalDir, { recursive: true, force: true });
+        }
+        await rename(tempDir, params.portalDir);
+    }
+    catch (error) {
+        await rm(tempDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function replacePortalSourceFromDirectory(params) {
+    const targetExists = await pathExists(params.portalDir);
+    if (targetExists && !params.force) {
+        throw new Error(portalSourceText('errors.workspaceExists', { portalDir: params.portalDir }, `Portal workspace already exists: ${params.portalDir}\nPass --force to delete it and pull again.`));
+    }
+    const parentDir = path.dirname(params.portalDir);
+    const tempDir = await mkdtemp(path.join(parentDir, `.${path.basename(params.portalDir)}-pull-`));
+    try {
+        await cp(params.sourceDir, tempDir, {
+            recursive: true,
+            filter: (source) => shouldPackPortalSourceEntry(path.relative(params.sourceDir, source)),
+        });
+        if (targetExists) {
+            await rm(params.portalDir, { recursive: true, force: true });
+        }
+        await rename(tempDir, params.portalDir);
+    }
+    catch (error) {
+        await rm(tempDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function runGit(args, cwd) {
+    return await execFileAsync('git', args, {
+        cwd,
+        maxBuffer: 10 * 1024 * 1024,
+    });
+}
+function readSourceRevision(data) {
+    if (!data || typeof data !== 'object' || Array.isArray(data)) {
+        return undefined;
+    }
+    const direct = data.sourceRevision;
+    if (typeof direct === 'string' && direct.trim()) {
+        return direct;
+    }
+    return readSourceRevision(data.data);
+}
+async function resolvePortalSourceContext(options) {
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app, appPublicPath } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    const portalBase = buildPortalBasePath({ app, appPublicPath, portal });
+    const mode = options.env.kind;
+    if (mode !== 'local' && mode !== 'docker' && mode !== 'http') {
+        throw new Error(portalSourceText('errors.unsupportedEnvKind', { kind: mode }, `Cannot sync Portal source for ${mode} envs in the first version.`));
+    }
+    const list = await listPortalWorkspaces({
+        env: options.env,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const item = findPortalListItem(list.items, portal);
+    if (!item) {
+        throw new Error(portalSourceText('errors.notFound', { portal }, `Portal "${portal}" was not found. Run \`nb portal list\` to see available portals.`));
+    }
+    return {
+        app,
+        portal,
+        portalDir,
+        portalBase,
+        mode,
+        sourceStorage: item.sourceStorage || 'nocobase',
+        gitRepo: item.gitRepo,
+        gitBranch: item.gitBranch || 'main',
+        gitPath: item.gitPath || portal,
+    };
+}
+function assertGitSourceConfig(context) {
+    if (!context.gitRepo) {
+        throw new Error(portalSourceText('errors.gitRepoMissing', { portal: context.portal }, `Portal "${context.portal}" uses Git source storage, but gitRepo is missing.`));
+    }
+    return {
+        repo: context.gitRepo,
+        branch: context.gitBranch || 'main',
+        gitPath: context.gitPath || context.portal,
+    };
+}
+async function cloneGitSource(params) {
+    const repoDir = path.join(params.cwd, 'repo');
+    try {
+        await runGit(['clone', '--branch', params.branch, params.repo, repoDir]);
+    }
+    catch (error) {
+        if (!params.createBranch) {
+            throw error;
+        }
+        await runGit(['clone', params.repo, repoDir]);
+        await runGit(['checkout', '-B', params.branch], repoDir);
+    }
+    return repoDir;
+}
+async function pullGitPortalSource(params) {
+    const git = assertGitSourceConfig(params.context);
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-git-pull-'));
+    try {
+        const repoDir = await cloneGitSource({
+            repo: git.repo,
+            branch: git.branch,
+            cwd: tempDir,
+            createBranch: true,
+        });
+        const sourceDir = path.join(repoDir, git.gitPath);
+        if (!(await pathExists(sourceDir))) {
+            throw new Error(portalSourceText('errors.gitPathMissing', { gitPath: git.gitPath }, `Git path does not exist in the configured repository: ${git.gitPath}`));
+        }
+        await mkdir(path.dirname(params.context.portalDir), { recursive: true });
+        await replacePortalSourceFromDirectory({
+            sourceDir,
+            portalDir: params.context.portalDir,
+            force: params.force,
+        });
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+async function pushGitPortalSource(params) {
+    const git = assertGitSourceConfig(params.context);
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-git-push-'));
+    try {
+        const repoDir = await cloneGitSource({
+            repo: git.repo,
+            branch: git.branch,
+            cwd: tempDir,
+        });
+        const targetDir = path.join(repoDir, git.gitPath);
+        await rm(targetDir, { recursive: true, force: true });
+        await mkdir(path.dirname(targetDir), { recursive: true });
+        await cp(params.context.portalDir, targetDir, {
+            recursive: true,
+            filter: (source) => shouldPackPortalSourceEntry(path.relative(params.context.portalDir, source)),
+        });
+        await runGit(['add', git.gitPath], repoDir);
+        const status = await runGit(['status', '--porcelain', '--', git.gitPath], repoDir);
+        if (!status.stdout.trim()) {
+            return undefined;
+        }
+        await runGit([
+            '-c',
+            'user.name=NocoBase CLI',
+            '-c',
+            'user.email=nocobase-cli@localhost',
+            'commit',
+            '-m',
+            trimValue(params.message) || `chore(portal): update ${params.context.portal}`,
+        ], repoDir);
+        await runGit(['push', 'origin', git.branch], repoDir);
+        const revision = await runGit(['rev-parse', 'HEAD'], repoDir);
+        return revision.stdout.trim();
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function pullPortalSource(options) {
+    const context = await resolvePortalSourceContext(options);
+    if (context.sourceStorage === 'git') {
+        await pullGitPortalSource({
+            context,
+            force: options.force,
+        });
+        return {
+            ...context,
+            changed: true,
+        };
+    }
+    if (context.sourceStorage !== 'nocobase') {
+        throw new Error(portalSourceText('errors.unsupportedSourceStorage', { sourceStorage: context.sourceStorage }, `Unsupported Portal source storage: ${context.sourceStorage}`));
+    }
+    if (context.mode === 'local' || context.mode === 'docker') {
+        return {
+            ...context,
+            changed: false,
+            noopReason: context.mode === 'local'
+                ? portalSourceText('messages.localPullNoop', undefined, 'Portal source is already local.')
+                : portalSourceText('messages.dockerPullNoop', undefined, 'Portal source is already available through the Docker volume.'),
+        };
+    }
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-cli-portal-pull-'));
+    const archivePath = path.join(tempDir, 'source.tar.gz');
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    try {
+        const response = await apiRequest({
+            cliVersion: options.cliVersion ?? '',
+            envName: options.envName,
+            flags: {
+                app: context.app,
+                portal: context.portal,
+                output: archivePath,
+            },
+            operation: PULL_SOURCE_OPERATION,
+        });
+        if (!response.ok) {
+            throw new Error(portalSourceText('errors.pullFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal source pull failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+        }
+        await mkdir(path.dirname(context.portalDir), { recursive: true });
+        await replacePortalSourceFromArchive({
+            archivePath,
+            portalDir: context.portalDir,
+            force: options.force,
+        });
+        return {
+            ...context,
+            changed: true,
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function pushPortalSource(options) {
+    const context = await resolvePortalSourceContext(options);
+    if (context.sourceStorage === 'git') {
+        if (!(await pathExists(context.portalDir))) {
+            throw new Error(portalSourceText('errors.workspaceMissing', { portalDir: context.portalDir, portal: context.portal }, `Portal workspace does not exist: ${context.portalDir}\nRun \`nb portal create ${context.portal}\` first.`));
+        }
+        const revision = await pushGitPortalSource({
+            context,
+            message: options.message,
+        });
+        return {
+            ...context,
+            changed: Boolean(revision),
+            sourceRevision: revision,
+            noopReason: revision
+                ? undefined
+                : portalSourceText('messages.gitPushNoop', undefined, 'No local source changes to push.'),
+        };
+    }
+    if (context.sourceStorage !== 'nocobase') {
+        throw new Error(portalSourceText('errors.unsupportedSourceStorage', { sourceStorage: context.sourceStorage }, `Unsupported Portal source storage: ${context.sourceStorage}`));
+    }
+    if (context.mode === 'local' || context.mode === 'docker') {
+        return {
+            ...context,
+            changed: false,
+            noopReason: context.mode === 'local'
+                ? portalSourceText('messages.localPushNoop', undefined, 'Portal source is already local.')
+                : portalSourceText('messages.dockerPushNoop', undefined, 'Portal source is already available through the Docker volume.'),
+        };
+    }
+    if (!(await pathExists(context.portalDir))) {
+        throw new Error(portalSourceText('errors.workspaceMissing', { portalDir: context.portalDir, portal: context.portal }, `Portal workspace does not exist: ${context.portalDir}\nRun \`nb portal create ${context.portal}\` first.`));
+    }
+    const archive = await packPortalSource(context.portalDir);
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    try {
+        const response = await apiRequest({
+            cliVersion: options.cliVersion ?? '',
+            envName: options.envName,
+            flags: {
+                file: archive.archivePath,
+                app: context.app,
+                portal: context.portal,
+                message: options.message,
+            },
+            operation: PUSH_SOURCE_OPERATION,
+        });
+        if (!response.ok) {
+            throw new Error(portalSourceText('errors.pushFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal source push failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+        }
+        return {
+            ...context,
+            changed: true,
+            sourceRevision: readSourceRevision(response.data),
+        };
+    }
+    finally {
+        await archive.cleanup();
+    }
+}