@nocobase/cli 2.1.9 → 2.1.11-test.1

package/dist/commands/source/download.js

@@ -13,6 +13,9 @@ import { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
 import { runPromptCatalog, } from "../../lib/prompt-catalog.js";
 import { applyCliLocale, CLI_LOCALE_FLAG_DESCRIPTION, CLI_LOCALE_FLAG_OPTIONS, localeText, resolveCliLocale, translateCli, } from "../../lib/cli-locale.js";
 import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_REGISTRY_ZH_CN, resolveDockerImageRef, } from "../../lib/docker-image.js";
+import { getEnv } from '../../lib/auth-store.js';
+import { resolveDefaultConfigScope } from '../../lib/cli-home.js';
+import { buildBeforeDependencyInstallHookContext, runBeforeDependencyInstallHook, } from '../../lib/hook-script.js';
 import { run } from "../../lib/run-npm.js";
 import { printVerbose, setVerboseMode, startTask, stopTask, updateTask } from '../../lib/ui.js';
 const DEFAULT_DOCKER_PLATFORM = 'auto';
@@ -231,6 +234,26 @@ export default class SourceDownload extends Command {
         'npm-registry': Flags.string({
             description: 'npm registry for npm/git downloads and dependency installation.',
         }),
+        'hook-script': Flags.string({
+            description: 'Hook module to run after npm scaffold or git clone and before dependency installation.',
+        }),
+        'hook-phase': Flags.string({
+            hidden: true,
+            options: ['init', 'upgrade', 'restore', 'source-download', 'app-start'],
+        }),
+        'hook-command': Flags.string({
+            hidden: true,
+            options: ['init', 'source:download', 'app:start', 'app:restart', 'app:upgrade'],
+        }),
+        'hook-env-name': Flags.string({
+            hidden: true,
+        }),
+        'hook-app-path': Flags.string({
+            hidden: true,
+        }),
+        'hook-storage-path': Flags.string({
+            hidden: true,
+        }),
         build: Flags.boolean({
             allowNo: true,
             description: 'Build npm/git source after dependencies are installed.',
@@ -573,6 +596,9 @@ export default class SourceDownload extends Command {
         const npmRegistryRaw = results.npmRegistry !== undefined ? String(results.npmRegistry) : flags['npm-registry'] ?? '';
         const npmRegistry = npmRegistryRaw.trim() || undefined;
         const npmDevDependencies = devDependencies ?? false;
+        const hookScript = flags['hook-script']?.trim()
+            ? path.resolve(process.cwd(), flags['hook-script'].trim())
+            : undefined;
         return {
             source,
             version,
@@ -586,6 +612,14 @@ export default class SourceDownload extends Command {
             ...(source === 'docker' ? { 'docker-platform': dockerPlatform } : {}),
             ...(source === 'docker' ? { 'docker-save': dockerSave } : {}),
             ...(npmRegistry ? { 'npm-registry': npmRegistry } : {}),
+            ...(hookScript ? { 'hook-script': hookScript } : {}),
+            ...(flags['hook-phase'] ? { 'hook-phase': flags['hook-phase'] } : {}),
+            ...(flags['hook-command'] ? { 'hook-command': flags['hook-command'] } : {}),
+            ...(flags['hook-env-name'] ? { 'hook-env-name': flags['hook-env-name'].trim() } : {}),
+            ...(flags['hook-app-path'] ? { 'hook-app-path': path.resolve(process.cwd(), flags['hook-app-path']) } : {}),
+            ...(flags['hook-storage-path']
+                ? { 'hook-storage-path': path.resolve(process.cwd(), flags['hook-storage-path']) }
+                : {}),
         };
     }
     async resolveDownloadFlags(flags) {
@@ -718,6 +752,36 @@ export default class SourceDownload extends Command {
         }
         return argv;
     }
+    async runBeforeDependencyInstallHookIfNeeded(flags, projectRoot) {
+        const hookScript = flags['hook-script']?.trim();
+        if (!hookScript || (flags.source !== 'npm' && flags.source !== 'git')) {
+            return;
+        }
+        const envName = flags['hook-env-name']?.trim() || '';
+        const env = envName ? await getEnv(envName, { scope: resolveDefaultConfigScope() }) : undefined;
+        const appPath = flags['hook-app-path']?.trim() || projectRoot;
+        const storagePath = flags['hook-storage-path']?.trim() || path.join(appPath, 'storage');
+        const context = buildBeforeDependencyInstallHookContext({
+            phase: flags['hook-phase'] ?? 'source-download',
+            command: flags['hook-command'] ?? 'source:download',
+            envName,
+            source: flags.source,
+            version: flags.version,
+            appPath,
+            sourcePath: projectRoot,
+            storagePath,
+            hookScript,
+            envConfig: env?.config ?? {},
+        });
+        if (!context) {
+            return;
+        }
+        this.log(`Running hook before dependency install: ${hookScript}`);
+        await runBeforeDependencyInstallHook({
+            hookScriptPath: hookScript,
+            context,
+        });
+    }
     async downloadFromDocker(flags) {
         const imageRef = resolveDockerImageRef(flags['docker-registry'], flags.version, {
             defaultRegistry: defaultDockerRegistryForLang(process.env.NB_LOCALE),
@@ -777,6 +841,7 @@ export default class SourceDownload extends Command {
             errorName: 'npx create-nocobase-app',
             loadingMessage: 'Creating the app scaffold',
         });
+        await this.runBeforeDependencyInstallHookIfNeeded(flags, projectRoot);
         const installArgs = ['install'];
         if (!flags['dev-dependencies']) {
             installArgs.push('--production');
@@ -820,6 +885,7 @@ export default class SourceDownload extends Command {
         });
         const projectRoot = path.resolve(process.cwd(), outputDir);
         const registryEnv = this.npmRegistryEnv(flags);
+        await this.runBeforeDependencyInstallHookIfNeeded(flags, projectRoot);
         this.log(`Installing dependencies in ${projectRoot}`);
         await this.runExternalCommand('yarn', ['install'], {
             ...this.runOptionsWithCwd(projectRoot, registryEnv),

package/dist/lib/app-managed-resources.js

@@ -6,13 +6,16 @@
  * 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, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
 import { resolveAppPublicPath } from './app-public-path.js';
 import { dockerContainerExists, managedAppLifecycleEnvVars, runLocalNocoBaseCommand, startDockerContainer, } from './app-runtime.js';
 import { deriveBuiltinDbConnection, resolveBuiltinDbConnection } from './builtin-db.js';
 import { resolveConfiguredStoragePath } from './env-paths.js';
 import { resolveDockerEnvFileArg } from "./docker-env-file.js";
 import { DEFAULT_DOCKER_REGISTRY, DEFAULT_DOCKER_VERSION, resolveDockerImageRef, } from "./docker-image.js";
+import { resolveHookScriptPath } from './hook-script.js';
 import { commandSucceeds, ensureDockerDaemonRunning, run } from './run-npm.js';
 import Install from '../commands/install.js';
 const DOCKER_APP_STORAGE_DESTINATION = '/app/nocobase/storage';
@@ -90,6 +93,15 @@ function formatLocalPostinstallFailure(envName, message) {
         `Details: ${message}`,
     ].join('\n');
 }
+function formatNpmSourceDevDependenciesFailure(envName, projectRoot, message) {
+    return [
+        `Couldn't prepare source dev dependencies for "${envName}".`,
+        '`nb source dev` requires @nocobase/devtools in npm source envs.',
+        `Source directory: ${projectRoot}`,
+        `Run \`cd ${projectRoot} && yarn install\` after fixing package.json, then try again.`,
+        `Details: ${message}`,
+    ].join('\n');
+}
 function formatSavedDockerSettingsIncomplete(envName, missing) {
     return [
         `Can't start NocoBase for "${envName}" yet.`,
@@ -114,6 +126,45 @@ async function localProjectHasFiles(projectRoot) {
         return false;
     }
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function readPackageJson(projectRoot) {
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    const content = await readFile(packageJsonPath, 'utf-8');
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed)) {
+        throw new Error(`${packageJsonPath} must contain a JSON object.`);
+    }
+    return parsed;
+}
+function getStringDependency(packageJson, section, packageName) {
+    const dependencies = packageJson[section];
+    if (!isRecord(dependencies)) {
+        return undefined;
+    }
+    const version = dependencies[packageName];
+    return typeof version === 'string' && version.trim() ? version.trim() : undefined;
+}
+function ensureDevDependencies(packageJson) {
+    const devDependencies = packageJson.devDependencies;
+    if (devDependencies === undefined) {
+        const next = {};
+        packageJson.devDependencies = next;
+        return next;
+    }
+    if (!isRecord(devDependencies)) {
+        throw new Error('package.json devDependencies must be an object.');
+    }
+    return devDependencies;
+}
+function hasNpmSourceDevtools(projectRoot) {
+    return existsSync(path.join(projectRoot, 'node_modules', '@nocobase', 'devtools', 'package.json'));
+}
+function npmRegistryEnv(runtime) {
+    const npmRegistry = String(runtime.env.config?.npmRegistry ?? '').trim();
+    return npmRegistry ? { npm_config_registry: npmRegistry } : undefined;
+}
 export async function buildSavedDockerRunArgs(runtime, options) {
     const config = runtime.env.config ?? {};
     const storagePath = trimValue(resolveConfiguredStoragePath(config));
@@ -302,6 +353,13 @@ export function buildSavedLocalDownloadArgv(runtime, options) {
     if (config.buildDts === true) {
         argv.push('--build-dts');
     }
+    const hookScriptPath = resolveHookScriptPath({
+        appPath: runtime.env.appPath,
+        hookScript: config.hookScript,
+    });
+    if (hookScriptPath) {
+        argv.push('--hook-script', hookScriptPath, '--hook-phase', options?.hookPhase ?? 'restore', '--hook-command', options?.hookCommand ?? 'app:start', '--hook-env-name', runtime.envName, '--hook-app-path', runtime.env.appPath, '--hook-storage-path', runtime.env.storagePath);
+    }
     return argv;
 }
 export async function ensureSavedLocalSource(runtime, runCommand, options) {
@@ -313,6 +371,8 @@ export async function ensureSavedLocalSource(runtime, runCommand, options) {
     try {
         await runCommand('source:download', buildSavedLocalDownloadArgv(runtime, {
             verbose: options?.verbose,
+            hookPhase: options?.hookPhase,
+            hookCommand: options?.hookCommand,
         }));
         options?.onSucceedTask?.(`NocoBase files are ready for "${runtime.envName}".`);
     }
@@ -335,3 +395,43 @@ export async function ensureLocalPostinstall(runtime, options) {
         throw new Error(formatLocalPostinstallFailure(runtime.envName, error instanceof Error ? error.message : String(error)));
     }
 }
+export async function ensureNpmSourceDevDependencies(runtime, options) {
+    if (runtime.source !== 'npm') {
+        return;
+    }
+    let taskStarted = false;
+    try {
+        const packageJson = await readPackageJson(runtime.projectRoot);
+        const appVersion = getStringDependency(packageJson, 'dependencies', '@nocobase/app');
+        const devtoolsVersion = getStringDependency(packageJson, 'devDependencies', '@nocobase/devtools');
+        let updatedPackageJson = false;
+        if (!devtoolsVersion) {
+            if (!appVersion) {
+                throw new Error('Cannot determine @nocobase/devtools version because dependencies["@nocobase/app"] is missing.');
+            }
+            const devDependencies = ensureDevDependencies(packageJson);
+            devDependencies['@nocobase/devtools'] = appVersion;
+            updatedPackageJson = true;
+            await writeFile(path.join(runtime.projectRoot, 'package.json'), `${JSON.stringify(packageJson, null, 2)}\n`, 'utf-8');
+        }
+        const needsInstall = updatedPackageJson || !hasNpmSourceDevtools(runtime.projectRoot);
+        if (!needsInstall) {
+            return;
+        }
+        options?.onStartTask?.(`Preparing source dev dependencies for "${runtime.envName}"...`);
+        taskStarted = true;
+        await run('yarn', ['install'], {
+            cwd: runtime.projectRoot,
+            env: npmRegistryEnv(runtime),
+            errorName: 'yarn install',
+            stdio: commandStdio(options?.verbose),
+        });
+        options?.onSucceedTask?.(`Source dev dependencies are ready for "${runtime.envName}".`);
+    }
+    catch (error) {
+        if (taskStarted) {
+            options?.onFailTask?.(`Failed to prepare source dev dependencies for "${runtime.envName}".`);
+        }
+        throw new Error(formatNpmSourceDevDependenciesFailure(runtime.envName, runtime.projectRoot, error instanceof Error ? error.message : String(error)));
+    }
+}

package/dist/lib/auth-store.js

@@ -123,13 +123,19 @@ function normalizeAuthConfig(config) {
                     },
                 }
                 : {}),
-            ...(settings.bin?.docker || settings.bin?.caddy || settings.bin?.git || settings.bin?.nginx || settings.bin?.yarn
+            ...(settings.bin?.docker ||
+                settings.bin?.caddy ||
+                settings.bin?.git ||
+                settings.bin?.nginx ||
+                settings.bin?.pnpm ||
+                settings.bin?.yarn
                 ? {
                     bin: {
                         ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
                         ...(settings.bin?.caddy ? { caddy: normalizeOptionalString(settings.bin.caddy) } : {}),
                         ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
                         ...(settings.bin?.nginx ? { nginx: normalizeOptionalString(settings.bin.nginx) } : {}),
+                        ...(settings.bin?.pnpm ? { pnpm: normalizeOptionalString(settings.bin.pnpm) } : {}),
                         ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
                     },
                 }

package/dist/lib/cli-config.js

@@ -16,6 +16,7 @@ export const DEFAULT_DOCKER_BIN = 'docker';
 export const DEFAULT_CADDY_BIN = 'caddy';
 export const DEFAULT_GIT_BIN = 'git';
 export const DEFAULT_NGINX_BIN = 'nginx';
+export const DEFAULT_PNPM_BIN = 'pnpm';
 export const PROXY_PROVIDER_OPTIONS = ['nginx', 'caddy'];
 export const DEFAULT_PROXY_PROVIDER = 'nginx';
 export const NGINX_PROXY_DRIVER_OPTIONS = ['local', 'docker'];
@@ -40,6 +41,7 @@ export const SUPPORTED_CLI_CONFIG_KEYS = [
     'bin.caddy',
     'bin.git',
     'bin.nginx',
+    'bin.pnpm',
     'proxy.nb-cli-root',
     'proxy.caddy-driver',
     'proxy.nginx-driver',
@@ -136,6 +138,7 @@ function pruneSettings(config) {
         !trimValue(bin.caddy) &&
         !trimValue(bin.git) &&
         !trimValue(bin.nginx) &&
+        !trimValue(bin.pnpm) &&
         !trimValue(bin.yarn)) {
         delete config.settings?.bin;
     }
@@ -187,6 +190,8 @@ export function getExplicitCliConfigValue(config, key) {
             return trimValue(config.settings?.bin?.git);
         case 'bin.nginx':
             return trimValue(config.settings?.bin?.nginx);
+        case 'bin.pnpm':
+            return trimValue(config.settings?.bin?.pnpm);
         case 'proxy.nb-cli-root':
             return trimValue(config.settings?.proxy?.nbCliRoot);
         case 'proxy.caddy-driver':
@@ -233,6 +238,8 @@ export function getEffectiveCliConfigValue(config, key) {
             return DEFAULT_GIT_BIN;
         case 'bin.nginx':
             return DEFAULT_NGINX_BIN;
+        case 'bin.pnpm':
+            return DEFAULT_PNPM_BIN;
         case 'proxy.nb-cli-root':
             return explicit ?? resolveCliHomeRoot();
         case 'proxy.caddy-driver':
@@ -387,6 +394,12 @@ export async function setCliConfigValue(key, value, options = {}) {
                 nginx: normalized,
             };
             break;
+        case 'bin.pnpm':
+            config.settings.bin = {
+                ...(config.settings.bin ?? {}),
+                pnpm: normalized,
+            };
+            break;
         case 'proxy.nb-cli-root':
             config.settings.proxy = {
                 ...(config.settings.proxy ?? {}),
@@ -496,6 +509,11 @@ export async function deleteCliConfigValue(key, options = {}) {
                 delete config.settings.bin.nginx;
             }
             break;
+        case 'bin.pnpm':
+            if (config.settings.bin) {
+                delete config.settings.bin.pnpm;
+            }
+            break;
         case 'proxy.nb-cli-root':
             if (config.settings.proxy) {
                 delete config.settings.proxy.nbCliRoot;
@@ -556,6 +574,7 @@ const CONFIGURABLE_COMMAND_KEYS = {
     caddy: 'bin.caddy',
     git: 'bin.git',
     nginx: 'bin.nginx',
+    pnpm: 'bin.pnpm',
     yarn: 'bin.yarn',
 };
 export function isConfigurableCommandName(value) {

package/dist/lib/env-config.js

@@ -14,6 +14,7 @@ const STRING_ENV_CONFIG_KEYS = [
     'dockerPlatform',
     'gitUrl',
     'npmRegistry',
+    'hookScript',
     'appPath',
     'appRootPath',
     'storagePath',

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/run-npm.js

@@ -44,6 +44,10 @@ const MISSING_COMMAND_SPECS = {
         displayName: 'Yarn',
         configKey: 'bin.yarn',
     },
+    pnpm: {
+        displayName: 'pnpm',
+        configKey: 'bin.pnpm',
+    },
 };
 const DOCKER_DAEMON_UNAVAILABLE_PATTERNS = [
     /cannot connect to the docker daemon/i,