@nocobase/cli 2.2.0-alpha.1 → 2.2.0-alpha.11

package/dist/lib/hook-script.js

@@ -0,0 +1,160 @@
+/**
+ * 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 { copyFile, mkdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+export const ENV_HOOK_SCRIPT_CONFIG_PATH = '.nb/hooks.mjs';
+const require = createRequire(import.meta.url);
+const { spawn } = require('node:child_process');
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function normalizeHookPhase(value) {
+    const text = trimValue(value);
+    if (text === 'init' || text === 'upgrade' || text === 'restore' || text === 'source-download' || text === 'app-start') {
+        return text;
+    }
+    return 'init';
+}
+function normalizeHookCommand(value) {
+    const text = trimValue(value);
+    if (text === 'source:download' || text === 'app:start' || text === 'app:restart' || text === 'app:upgrade') {
+        return text;
+    }
+    return 'init';
+}
+function normalizeHookSource(value) {
+    const text = trimValue(value);
+    if (text === 'npm' || text === 'git' || text === 'docker') {
+        return text;
+    }
+    return undefined;
+}
+function isDependencyHookSource(source) {
+    return source === 'npm' || source === 'git';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function resolveHookScriptPath(params) {
+    const hookScript = trimValue(params.hookScript);
+    if (!hookScript) {
+        return undefined;
+    }
+    if (path.isAbsolute(hookScript)) {
+        return hookScript;
+    }
+    const appPath = trimValue(params.appPath);
+    if (!appPath) {
+        return hookScript;
+    }
+    const usesWindowsSeparators = appPath.includes('\\') || /^[a-zA-Z]:([\\/]|$)/.test(appPath) || appPath.startsWith('\\\\');
+    return usesWindowsSeparators ? path.win32.join(appPath, hookScript) : path.posix.join(appPath, hookScript);
+}
+export async function persistHookScript(params) {
+    const sourcePath = path.resolve(params.sourcePath);
+    const targetPath = path.join(params.appPath, ENV_HOOK_SCRIPT_CONFIG_PATH);
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    if (path.resolve(sourcePath) !== path.resolve(targetPath)) {
+        await copyFile(sourcePath, targetPath);
+    }
+    return ENV_HOOK_SCRIPT_CONFIG_PATH;
+}
+const hookRunnerScript = `
+import { pathToFileURL } from 'node:url';
+
+const knownHookNames = ['beforeDependencyInstall', 'beforeAppInstall', 'afterAppStart'];
+const [, hookScriptPath, hookName, contextJson] = process.argv;
+const url = pathToFileURL(hookScriptPath);
+url.searchParams.set('t', String(Date.now()));
+
+const imported = await import(url.href);
+const hooks = imported.default ?? imported;
+
+if (!hooks || typeof hooks !== 'object' || Array.isArray(hooks)) {
+  throw new Error('Hook script must export an object.');
+}
+
+for (const knownHookName of knownHookNames) {
+  if (Object.prototype.hasOwnProperty.call(hooks, knownHookName) && typeof hooks[knownHookName] !== 'function') {
+    throw new Error(\`Hook "\${knownHookName}" must be a function.\`);
+  }
+}
+
+const hook = hooks[hookName];
+if (typeof hook === 'function') {
+  await hook(JSON.parse(contextJson));
+}
+`;
+async function runHookInSubprocess(params) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, ['--input-type=module', '--eval', hookRunnerScript, params.hookScriptPath, params.hookName, JSON.stringify(params.context)], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on?.('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on?.('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.once('error', reject);
+        child.once('close', (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const output = stderr.trim() || stdout.trim();
+            reject(new Error(output || `Hook process exited with code ${code ?? 'unknown'}.`));
+        });
+    });
+}
+export function buildHookContext(params) {
+    const source = normalizeHookSource(params.source);
+    if (!source) {
+        return undefined;
+    }
+    const version = trimValue(params.version);
+    return {
+        phase: normalizeHookPhase(params.phase),
+        command: normalizeHookCommand(params.command),
+        envName: trimValue(params.envName),
+        source,
+        ...(version ? { version } : {}),
+        appPath: params.appPath,
+        sourcePath: params.sourcePath,
+        storagePath: params.storagePath,
+        hookScript: params.hookScript,
+        envConfig: { ...(params.envConfig ?? {}) },
+    };
+}
+export function buildBeforeDependencyInstallHookContext(params) {
+    const context = buildHookContext(params);
+    if (!context || !isDependencyHookSource(context.source)) {
+        return undefined;
+    }
+    return context;
+}
+export async function runHookScriptHook(params) {
+    try {
+        await runHookInSubprocess(params);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error([`Hook script failed: ${params.hookScriptPath}`, `Hook stage: ${params.hookName}`, `Details: ${message}`].join('\n'));
+    }
+}
+export async function runBeforeDependencyInstallHook(params) {
+    await runHookScriptHook({
+        hookScriptPath: params.hookScriptPath,
+        hookName: 'beforeDependencyInstall',
+        context: params.context,
+    });
+}

package/dist/lib/managed-init-env.js

@@ -15,7 +15,7 @@ export function resolveManagedSetupState(value) {
 export function isPreparedSetupState(value) {
     return resolveManagedSetupState(value) === 'prepared';
 }
-export function buildInitAppEnvVarsFromConfig(config) {
+export function buildInitAppEnvVarsFromConfig(config, options = {}) {
     const out = {};
     const put = (key, value) => {
         const text = trimValue(value);
@@ -28,5 +28,10 @@ export function buildInitAppEnvVarsFromConfig(config) {
     put('INIT_ROOT_EMAIL', config?.rootEmail);
     put('INIT_ROOT_PASSWORD', config?.rootPassword);
     put('INIT_ROOT_NICKNAME', config?.rootNickname);
+    if (options.includePortal !== false) {
+        put('INIT_PORTAL_TYPE', config?.portalType);
+        put('INIT_PORTAL_NAME', config?.portalName);
+        put('INIT_PORTAL_TEMPLATE', config?.portalTemplate);
+    }
     return out;
 }

package/dist/lib/portal-command-env.js

@@ -0,0 +1,31 @@
+/**
+ * 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.
+ */
+const PORTAL_COMMAND_BASE_ENV_KEYS = [
+    'PATH',
+    'Path',
+    'PATHEXT',
+    'SystemRoot',
+    'WINDIR',
+    'ComSpec',
+    'HOME',
+    'USERPROFILE',
+    'TMPDIR',
+    'TEMP',
+    'TMP',
+];
+export function buildPortalCommandEnv(env = {}) {
+    const out = {};
+    for (const key of PORTAL_COMMAND_BASE_ENV_KEYS) {
+        const value = process.env[key];
+        if (value) {
+            out[key] = value;
+        }
+    }
+    return { ...out, ...env };
+}

package/dist/lib/portal-config.js

@@ -0,0 +1,133 @@
+/**
+ * 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 { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { executeApiRequest } from './api-client.js';
+import { translateCli } from './cli-locale.js';
+export const DEFAULT_PORTAL_GIT_PATH = '.';
+const portalConfigText = (key, values, fallback) => translateCli(`commands.portalConfig.${key}`, values, { fallback });
+const UPDATE_PORTAL_OPERATION = {
+    method: 'POST',
+    pathTemplate: '/multiPortals:update',
+    hasBody: true,
+    bodyRequired: true,
+    parameters: [
+        {
+            name: 'filterByTk',
+            flagName: 'filterByTk',
+            in: 'query',
+            required: true,
+        },
+    ],
+};
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function readObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function validatePortalSourceStorage(value) {
+    const sourceStorage = trimValue(value) || 'nocobase';
+    if (sourceStorage === 'nocobase' || sourceStorage === 'git') {
+        return sourceStorage;
+    }
+    throw new Error(portalConfigText('errors.invalidSourceStorage', { value: sourceStorage }, `Invalid source storage "${sourceStorage}". Use "nocobase" or "git".`));
+}
+function isFullGitRemoteUrl(value) {
+    return /^(?:https?:\/\/|ssh:\/\/|file:\/\/|git@[^:]+:).+/.test(value);
+}
+function validateGitPath(value) {
+    const gitPath = trimValue(value);
+    if (!gitPath || path.isAbsolute(gitPath) || gitPath.split(/[\\/]+/).includes('..')) {
+        throw new Error(portalConfigText('errors.invalidGitPath', { value }, '--git-path must be a relative path inside the Git repository.'));
+    }
+    return gitPath.replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+}
+export function buildPortalConfig(options) {
+    const sourceStorage = validatePortalSourceStorage(options.sourceStorage ?? options.existingConfig?.sourceStorage);
+    const hasGitOption = Boolean(trimValue(options.gitRepo) || trimValue(options.gitBranch) || trimValue(options.gitPath));
+    if (sourceStorage === 'nocobase') {
+        if (hasGitOption) {
+            throw new Error(portalConfigText('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) || options.existingConfig?.git?.repo || '';
+    if (!repo) {
+        throw new Error(portalConfigText('errors.gitRepoRequired', undefined, '--git-repo is required when --source-storage is git.'));
+    }
+    if (!isFullGitRemoteUrl(repo)) {
+        throw new Error(portalConfigText('errors.gitRepoInvalid', undefined, '--git-repo must be a full Git remote URL.'));
+    }
+    return {
+        sourceStorage,
+        git: {
+            repo,
+            branch: trimValue(options.gitBranch) || options.existingConfig?.git?.branch || 'main',
+            path: validateGitPath(trimValue(options.gitPath) || options.existingConfig?.git?.path || DEFAULT_PORTAL_GIT_PATH),
+        },
+    };
+}
+export function buildPortalConfigFromOptions(options, portal) {
+    const sourceOptions = readObject(options);
+    const git = readObject(sourceOptions.git);
+    return buildPortalConfig({
+        portal,
+        sourceStorage: trimValue(sourceOptions.sourceStorage) || 'nocobase',
+        gitRepo: trimValue(git.repo),
+        gitBranch: trimValue(git.branch),
+        gitPath: trimValue(git.path),
+    });
+}
+export function mergePortalConfigIntoOptions(config, currentOptions) {
+    const nextOptions = {
+        ...(currentOptions ?? {}),
+        sourceStorage: config.sourceStorage,
+    };
+    if (config.sourceStorage === 'git') {
+        nextOptions.git = config.git;
+    }
+    else {
+        delete nextOptions.git;
+    }
+    return nextOptions;
+}
+export async function readPortalConfig(portalDir) {
+    const configPath = path.join(portalDir, 'portal.config.json');
+    const data = JSON.parse(await readFile(configPath, 'utf-8'));
+    const config = readObject(data);
+    const git = readObject(config.git);
+    return buildPortalConfig({
+        portal: path.basename(portalDir),
+        sourceStorage: trimValue(config.sourceStorage),
+        gitRepo: trimValue(git.repo),
+        gitBranch: trimValue(git.branch),
+        gitPath: trimValue(git.path),
+    });
+}
+export async function writePortalConfig(portalDir, config) {
+    await writeFile(path.join(portalDir, 'portal.config.json'), `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+}
+export async function syncPortalConfigToRemote(options) {
+    const apiRequest = options.apiRequest ?? executeApiRequest;
+    const response = await apiRequest({
+        cliVersion: options.cliVersion ?? '',
+        envName: options.envName,
+        flags: {
+            filterByTk: options.portal,
+            body: JSON.stringify({
+                options: mergePortalConfigIntoOptions(options.config, options.currentOptions),
+            }),
+        },
+        operation: UPDATE_PORTAL_OPERATION,
+    });
+    if (!response.ok) {
+        throw new Error(portalConfigText('errors.updateFailed', { status: response.status, details: JSON.stringify(response.data, null, 2) }, `Portal config update failed with status ${response.status}\n${JSON.stringify(response.data, null, 2)}`));
+    }
+}

package/dist/lib/portal-configure.js

@@ -0,0 +1,117 @@
+/**
+ * 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 { mkdir, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { translateCli } from './cli-locale.js';
+import { resolvePortalAppFromApiBaseUrl, resolvePortalStoragePath, validatePortalSlug, } from './portal-create.js';
+import { buildPortalConfig, buildPortalConfigFromOptions, readPortalConfig, syncPortalConfigToRemote, writePortalConfig, } from './portal-config.js';
+import { findPortalListItem } from './portal-info.js';
+import { listPortalWorkspaces } from './portal-list.js';
+const portalConfigureText = (key, values, fallback) => translateCli(`commands.portalConfigure.${key}`, values, { fallback });
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+async function pathExists(target) {
+    try {
+        await stat(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasConfigurationChange(options) {
+    return Boolean(options.sourceStorage !== undefined ||
+        trimValue(options.gitRepo) ||
+        trimValue(options.gitBranch) ||
+        trimValue(options.gitPath));
+}
+async function readExistingConfig(portalDir) {
+    try {
+        return await readPortalConfig(portalDir);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+}
+function buildConfigFromRemoteOptions(params) {
+    if (params.options && Object.keys(params.options).length > 0) {
+        return buildPortalConfigFromOptions(params.options, params.portal);
+    }
+    if (!params.sourceStorage && !params.gitRepo && !params.gitBranch && !params.gitPath) {
+        return undefined;
+    }
+    return buildPortalConfig({
+        portal: params.portal,
+        sourceStorage: params.sourceStorage,
+        gitRepo: params.gitRepo,
+        gitBranch: params.gitBranch,
+        gitPath: params.gitPath,
+    });
+}
+export async function configurePortalWorkspace(options) {
+    if (!hasConfigurationChange(options)) {
+        throw new Error(portalConfigureText('errors.noChanges', undefined, 'No portal configuration changes were provided. Pass --source-storage or a --git-* flag.'));
+    }
+    const portal = validatePortalSlug(options.portal);
+    const apiBaseUrl = trimValue(options.env.apiBaseUrl);
+    const storagePath = resolvePortalStoragePath(options.env);
+    const { app } = resolvePortalAppFromApiBaseUrl(apiBaseUrl, options.env.config.appPublicPath);
+    const portalDir = path.join(storagePath, 'portals', app, portal);
+    if (!(await pathExists(portalDir))) {
+        throw new Error(portalConfigureText('errors.workspaceMissing', { portalDir, portal }, `Portal does not exist: ${portalDir}\nRun \`nb portal create ${portal}\` or \`nb portal pull ${portal}\` first.`));
+    }
+    const list = await listPortalWorkspaces({
+        env: options.env,
+        envName: options.envName,
+        cliVersion: options.cliVersion,
+        apiRequest: options.apiRequest,
+    });
+    const remoteItem = findPortalListItem(list.items, portal);
+    const existingConfig = (await readExistingConfig(portalDir)) ??
+        buildConfigFromRemoteOptions({
+            portal,
+            options: remoteItem?.options,
+            sourceStorage: remoteItem?.sourceStorage,
+            gitRepo: remoteItem?.gitRepo,
+            gitBranch: remoteItem?.gitBranch,
+            gitPath: remoteItem?.gitPath,
+        });
+    const config = buildPortalConfig({
+        portal,
+        sourceStorage: options.sourceStorage,
+        gitRepo: options.gitRepo,
+        gitBranch: options.gitBranch,
+        gitPath: options.gitPath,
+        existingConfig,
+    });
+    await mkdir(portalDir, { recursive: true });
+    await writePortalConfig(portalDir, config);
+    if (remoteItem) {
+        await syncPortalConfigToRemote({
+            portal,
+            config,
+            currentOptions: remoteItem.options,
+            envName: options.envName,
+            cliVersion: options.cliVersion,
+            apiRequest: options.apiRequest,
+        });
+    }
+    return {
+        app,
+        portal,
+        portalDir,
+        config,
+        remoteSynced: Boolean(remoteItem),
+    };
+}