@nocobase/server 2.1.0-beta.9 → 2.2.0-beta.1

package/lib/plugin-manager/options/resource.js

@@ -39,59 +39,193 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var resource_exports = {};
 __export(resource_exports, {
+  PackageUrls: () => PackageUrls,
   default: () => resource_default
 });
 module.exports = __toCommonJS(resource_exports);
 var import_utils = require("@nocobase/utils");
+var import_crypto = __toESM(require("crypto"));
 var import_fs = __toESM(require("fs"));
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
-var import_crypto = __toESM(require("crypto"));
+var import_plugin_manager = __toESM(require("../plugin-manager"));
+var import_utils2 = require("../utils");
 var import_package = __toESM(require("../../../package.json"));
+const PLUGIN_CLIENT_ENTRY_FILES = {
+  client: "dist/client/index.js",
+  "client-v2": "dist/client-v2/index.js"
+};
+const PLUGIN_CLIENT_MARKER_FILES = {
+  client: "client.js",
+  "client-v2": "client-v2.js"
+};
+function getAppDevPluginUrls() {
+  if (process.env.NOCOBASE_APP_DEV !== "true" || !process.env.NOCOBASE_APP_DEV_PLUGIN_URLS) {
+    return {};
+  }
+  try {
+    return JSON.parse(process.env.NOCOBASE_APP_DEV_PLUGIN_URLS);
+  } catch (error) {
+    return {};
+  }
+}
+__name(getAppDevPluginUrls, "getAppDevPluginUrls");
+function getAppDevPluginDependencies(packageJson2, lane) {
+  const appDevPluginUrls = getAppDevPluginUrls();
+  const deps = {
+    ...packageJson2.dependencies,
+    ...packageJson2.peerDependencies,
+    ...packageJson2.devDependencies
+  };
+  return Object.keys(deps).filter(
+    (packageName) => {
+      var _a;
+      return ((_a = appDevPluginUrls[packageName]) == null ? void 0 : _a[lane]) || packageName.startsWith("@nocobase/plugin-") || packageName.startsWith("@nocobase/preset-");
+    }
+  );
+}
+__name(getAppDevPluginDependencies, "getAppDevPluginDependencies");
 const _PackageUrls = class _PackageUrls {
-  static async get(packageName) {
-    if (!this.items[packageName]) {
-      this.items[packageName] = await this.fetch(packageName);
+  static clear() {
+    this.items = {};
+  }
+  static getCacheKey(packageName, lane) {
+    return `${lane}:${packageName}`;
+  }
+  static async get(packageName, lane = "client") {
+    const appDevUrl = this.getAppDevUrl(packageName, lane);
+    if (appDevUrl) {
+      return appDevUrl;
+    }
+    const cacheKey = this.getCacheKey(packageName, lane);
+    const cached = this.items[cacheKey];
+    if (cached) {
+      return cached;
     }
-    return this.items[packageName];
+    const nextUrl = await this.fetch(packageName, lane);
+    if (nextUrl == null ? void 0 : nextUrl.includes("?hash=")) {
+      this.items[cacheKey] = nextUrl;
+    } else {
+      delete this.items[cacheKey];
+    }
+    return nextUrl;
+  }
+  static getAppDevUrl(packageName, lane) {
+    var _a;
+    return (_a = getAppDevPluginUrls()[packageName]) == null ? void 0 : _a[lane];
   }
-  static async fetch(packageName) {
-    const PLUGIN_CLIENT_ENTRY_FILE = "dist/client/index.js";
+  static async hasClientEntry(packageName, lane) {
+    if (this.getAppDevUrl(packageName, lane)) {
+      return true;
+    }
     const pkgPath = import_path.default.resolve(process.env.NODE_MODULES_PATH, packageName);
-    const r = await import_fs_extra.default.exists(pkgPath);
-    if (r) {
-      let t = "";
-      const dist = import_path.default.resolve(pkgPath, PLUGIN_CLIENT_ENTRY_FILE);
-      const distExists = await import_fs_extra.default.exists(dist);
-      if (distExists) {
-        const fsState = await import_fs_extra.default.stat(distExists ? dist : pkgPath);
-        const appKey = process.env.APP_KEY || "";
-        let version = "";
-        try {
-          const pkgJson = await import_fs_extra.default.readJson(import_path.default.resolve(pkgPath, "package.json"));
-          if (pkgJson && typeof pkgJson.version === "string") {
-            version = pkgJson.version;
-          }
-        } catch (error) {
+    if (!await import_fs_extra.default.exists(pkgPath)) {
+      return false;
+    }
+    return await import_fs_extra.default.exists(import_path.default.resolve(pkgPath, PLUGIN_CLIENT_MARKER_FILES[lane]));
+  }
+  static async fetch(packageName, lane = "client") {
+    const pluginClientEntryFile = PLUGIN_CLIENT_ENTRY_FILES[lane];
+    const pkgPath = import_path.default.resolve(process.env.NODE_MODULES_PATH, packageName);
+    const pkgExists = await import_fs_extra.default.exists(pkgPath);
+    if (!pkgExists) {
+      return;
+    }
+    let t = "";
+    const dist = import_path.default.resolve(pkgPath, pluginClientEntryFile);
+    const distExists = await import_fs_extra.default.exists(dist);
+    if (distExists) {
+      const fsState = await import_fs_extra.default.stat(dist);
+      const appKey = process.env.APP_KEY || "";
+      let version = "";
+      try {
+        const pkgJson = await import_fs_extra.default.readJson(import_path.default.resolve(pkgPath, "package.json"));
+        if (pkgJson && typeof pkgJson.version === "string") {
+          version = pkgJson.version;
         }
-        const appVersion = import_package.default.version;
-        const salt = process.env.PLUGIN_URL_HASH_SALT || "";
-        const hash = import_crypto.default.createHash("sha256").update(fsState.mtime.getTime() + appKey + version + appVersion + salt).digest("hex").slice(0, 8);
-        t = `?hash=${hash}`;
-      }
-      const cdnBaseUrl = process.env.CDN_BASE_URL.replace(/\/+$/, "");
-      const url = `${cdnBaseUrl}${"/static/plugins/"}${packageName}/${PLUGIN_CLIENT_ENTRY_FILE}${t}`;
-      return url;
+      } catch (error) {
+      }
+      const appVersion = import_package.default.version;
+      const salt = process.env.PLUGIN_URL_HASH_SALT || "";
+      const hash = import_crypto.default.createHash("sha256").update(fsState.mtime.getTime() + appKey + version + appVersion + salt).digest("hex").slice(0, 8);
+      t = `?hash=${hash}`;
     }
+    const cdnBaseUrl = process.env.CDN_BASE_URL.replace(/\/+$/, "");
+    const url = `${cdnBaseUrl}${"/static/plugins/"}${packageName}/${pluginClientEntryFile}${t}`;
+    return url;
   }
 };
 __name(_PackageUrls, "PackageUrls");
 __publicField(_PackageUrls, "items", {});
 let PackageUrls = _PackageUrls;
+async function listEnabledPlugins(ctx, lane = "client") {
+  const pm = ctx.db.getRepository("applicationPlugins");
+  const items = await pm.find({
+    filter: {
+      enabled: true
+    }
+  });
+  const arr = [];
+  for (const item of items) {
+    if (lane === "client-v2" && !await PackageUrls.hasClientEntry(item.packageName, lane)) {
+      continue;
+    }
+    const url = await PackageUrls.get(item.packageName, lane);
+    const { name, packageName, options } = item.toJSON();
+    if (url) {
+      const entry = {
+        name,
+        packageName,
+        options,
+        url
+      };
+      if (PackageUrls.getAppDevUrl(packageName, lane)) {
+        const packageJson2 = await import_plugin_manager.default.getPackageJson(packageName);
+        entry.devMode = "esm";
+        entry.appDevDependencies = getAppDevPluginDependencies(packageJson2, lane);
+      }
+      if (lane === "client" && await PackageUrls.hasClientEntry(packageName, "client-v2")) {
+        const clientV2Url = await PackageUrls.get(packageName, "client-v2");
+        if (clientV2Url) {
+          entry.clientV2Url = clientV2Url;
+        }
+      }
+      arr.push(entry);
+    }
+  }
+  return arr;
+}
+__name(listEnabledPlugins, "listEnabledPlugins");
+function normalizePmPluginKeys(filterByTk) {
+  if (typeof filterByTk === "string") {
+    return filterByTk.split(",").map((k) => k.trim()).filter(Boolean);
+  }
+  if (!Array.isArray(filterByTk) || filterByTk.some((item) => typeof item !== "string")) {
+    return [];
+  }
+  return filterByTk.flatMap(
+    (item) => item.split(",").map((k) => k.trim()).filter(Boolean)
+  );
+}
+__name(normalizePmPluginKeys, "normalizePmPluginKeys");
+function coerceAwaitResponse(value) {
+  if (value === true || value === 1) {
+    return true;
+  }
+  if (typeof value === "string") {
+    const v = value.trim().toLowerCase();
+    return v === "true" || v === "1" || v === "yes";
+  }
+  return false;
+}
+__name(coerceAwaitResponse, "coerceAwaitResponse");
 var resource_default = {
   name: "pm",
   actions: {
     async add(ctx, next) {
+      if (process.env.DISABLE_PM_ADD === "true") {
+        ctx.throw(403, "The current environment does not allow adding plugins online");
+      }
       const app = ctx.app;
       const { values = {} } = ctx.action.params;
       if (values == null ? void 0 : values.packageName) {
@@ -107,12 +241,12 @@ var resource_default = {
         }
         app.runAsCLI(["pm", "add", values.packageName, ...args], { from: "user" });
       } else if (ctx.file) {
-        const tmpDir = import_path.default.resolve(process.cwd(), "storage", "tmp");
+        const tmpDir = (0, import_utils.storagePathJoin)("tmp");
         try {
           await import_fs.default.promises.mkdir(tmpDir, { recursive: true });
         } catch (error) {
         }
-        const tempFile = import_path.default.join(process.cwd(), "storage/tmp", (0, import_utils.uid)() + import_path.default.extname(ctx.file.originalname));
+        const tempFile = import_path.default.join(tmpDir, (0, import_utils.uid)() + import_path.default.extname(ctx.file.originalname));
         await import_fs.default.promises.writeFile(tempFile, ctx.file.buffer, "binary");
         app.runAsCLI(["pm", "add", tempFile], { from: "user" });
       } else if (values.compressedFileUrl) {
@@ -122,6 +256,9 @@ var resource_default = {
       await next();
     },
     async update(ctx, next) {
+      if (process.env.DISABLE_PM_ADD === "true") {
+        ctx.throw(403, "The current environment does not allow adding plugins online");
+      }
       const app = ctx.app;
       const values = ctx.action.params.values || {};
       const args = [];
@@ -136,12 +273,12 @@ var resource_default = {
       }
       if (ctx.file) {
         values.packageName = ctx.request.body.packageName;
-        const tmpDir = import_path.default.resolve(process.cwd(), "storage", "tmp");
+        const tmpDir = (0, import_utils.storagePathJoin)("tmp");
         try {
           await import_fs.default.promises.mkdir(tmpDir, { recursive: true });
         } catch (error) {
         }
-        const tempFile = import_path.default.join(process.cwd(), "storage/tmp", (0, import_utils.uid)() + import_path.default.extname(ctx.file.originalname));
+        const tempFile = import_path.default.join(tmpDir, (0, import_utils.uid)() + import_path.default.extname(ctx.file.originalname));
         await import_fs.default.promises.writeFile(tempFile, ctx.file.buffer, "binary");
         values.compressedFileUrl = tempFile;
       }
@@ -159,23 +296,40 @@ var resource_default = {
       await next();
     },
     async enable(ctx, next) {
-      const { filterByTk } = ctx.action.params;
+      const { filterByTk, awaitResponse: awaitResponseRaw } = ctx.action.params;
       const app = ctx.app;
-      if (!filterByTk) {
+      const keys = normalizePmPluginKeys(filterByTk);
+      if (!keys.length) {
         ctx.throw(400, "plugin name invalid");
       }
-      const keys = Array.isArray(filterByTk) ? filterByTk : [filterByTk];
-      app.runAsCLI(["pm", "enable", ...keys], { from: "user" });
+      const awaitResponse = coerceAwaitResponse(awaitResponseRaw);
+      const argv = ["pm", "enable", ...keys];
+      if (awaitResponse) {
+        await app.runAsCLI(argv, { from: "user", throwError: true });
+      } else {
+        void app.runAsCLI(argv, { from: "user" }).catch((err) => {
+          app.log.error(err);
+        });
+      }
       ctx.body = filterByTk;
       await next();
     },
     async disable(ctx, next) {
-      const { filterByTk } = ctx.action.params;
-      if (!filterByTk) {
+      const { filterByTk, awaitResponse: awaitResponseRaw } = ctx.action.params;
+      const app = ctx.app;
+      const keys = normalizePmPluginKeys(filterByTk);
+      if (!keys.length) {
         ctx.throw(400, "plugin name invalid");
       }
-      const app = ctx.app;
-      app.runAsCLI(["pm", "disable", filterByTk], { from: "user" });
+      const awaitResponse = coerceAwaitResponse(awaitResponseRaw);
+      const argv = ["pm", "disable", ...keys];
+      if (awaitResponse) {
+        await app.runAsCLI(argv, { from: "user", throwError: true });
+      } else {
+        void app.runAsCLI(argv, { from: "user" }).catch((err) => {
+          app.log.error(err);
+        });
+      }
       ctx.body = filterByTk;
       await next();
     },
@@ -190,6 +344,11 @@ var resource_default = {
       await next();
     },
     async list(ctx, next) {
+      const { mode } = ctx.action.params;
+      if (mode === "summary") {
+        ctx.body = await (0, import_utils2.pmListSummary)(ctx.app);
+        return next();
+      }
       const locale = ctx.getCurrentLocale();
       const pm = ctx.app.pm;
       const plugin = pm.get("nocobase");
@@ -197,29 +356,11 @@ var resource_default = {
       await next();
     },
     async listEnabled(ctx, next) {
-      const toArr = /* @__PURE__ */ __name(async () => {
-        const pm = ctx.db.getRepository("applicationPlugins");
-        const items = await pm.find({
-          filter: {
-            enabled: true
-          }
-        });
-        const arr = [];
-        for (const item of items) {
-          const url = await PackageUrls.get(item.packageName);
-          const { name, packageName, options } = item.toJSON();
-          if (url) {
-            arr.push({
-              name,
-              packageName,
-              options,
-              url
-            });
-          }
-        }
-        return arr;
-      }, "toArr");
-      ctx.body = await toArr();
+      ctx.body = await listEnabledPlugins(ctx, "client");
+      await next();
+    },
+    async listEnabledV2(ctx, next) {
+      ctx.body = await listEnabledPlugins(ctx, "client-v2");
       await next();
     },
     async get(ctx, next) {
@@ -235,3 +376,7 @@ var resource_default = {
     }
   }
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PackageUrls
+});

package/lib/plugin-manager/plugin-manager.d.ts

@@ -13,7 +13,6 @@ import Application from '../application';
 import { Plugin } from '../plugin';
 import { PluginManagerRepository } from './plugin-manager-repository';
 import { PluginData } from './types';
-import { checkAndGetCompatible } from './utils';
 export declare const sleep: (timeout?: number) => Promise<unknown>;
 export interface PluginManagerOptions {
     app: Application;
@@ -29,7 +28,12 @@ export declare class AddPresetError extends Error {
 }
 export declare class PluginManager {
     options: PluginManagerOptions;
-    static checkAndGetCompatible: typeof checkAndGetCompatible;
+    private static compatibleCache;
+    private static compatiblePending;
+    static checkAndGetCompatible(packageName: string): Promise<{
+        isCompatible: boolean;
+        depsCompatible: import("./utils").DepCompatible[];
+    }>;
     /**
      * @internal
      */
@@ -95,6 +99,7 @@ export declare class PluginManager {
     create(pluginName: string, options?: {
         forceRecreate?: boolean;
     }): Promise<void>;
+    addOrThrow(plugin?: string | typeof Plugin, options?: any, insert?: boolean, isUpgrade?: boolean): Promise<void>;
     add(plugin?: string | typeof Plugin, options?: any, insert?: boolean, isUpgrade?: boolean): Promise<void>;
     /**
      * @internal

package/lib/plugin-manager/plugin-manager.js

@@ -57,6 +57,7 @@ var import_middleware = require("./middleware");
 var import_collection = __toESM(require("./options/collection"));
 var import_resource = __toESM(require("./options/resource"));
 var import_plugin_manager_repository = require("./plugin-manager-repository");
+var import_plugin_package = require("../../../utils/plugin-package");
 var import_utils2 = require("./utils");
 const _PluginLoadError = class _PluginLoadError extends Error {
   constructor(pluginName) {
@@ -90,6 +91,7 @@ const _PluginManager = class _PluginManager {
     this._repository.setPluginManager(this);
     this.app.resourcer.define(import_resource.default);
     this.app.acl.allow("pm", "listEnabled", "public");
+    this.app.acl.allow("pm", "listEnabledV2", "public");
     this.app.acl.registerSnippet({
       name: "pm",
       actions: ["pm:*"]
@@ -100,6 +102,23 @@ const _PluginManager = class _PluginManager {
     });
     this.app.resourceManager.use(import_middleware.uploadMiddleware, { tag: "upload", after: "acl" });
   }
+  static async checkAndGetCompatible(packageName) {
+    if (this.compatibleCache.has(packageName)) {
+      return this.compatibleCache.get(packageName);
+    }
+    const pending = this.compatiblePending.get(packageName);
+    if (pending) {
+      return pending;
+    }
+    const task = (0, import_utils2.checkAndGetCompatible)(packageName).then((compatible) => {
+      this.compatibleCache.set(packageName, compatible);
+      return compatible;
+    }).finally(() => {
+      this.compatiblePending.delete(packageName);
+    });
+    this.compatiblePending.set(packageName, task);
+    return task;
+  }
   /**
    * @internal
    */
@@ -137,7 +156,11 @@ const _PluginManager = class _PluginManager {
    */
   static async getPackageJson(nameOrPkg) {
     const { packageName } = await this.parseName(nameOrPkg);
-    const packageFile = (0, import_path.resolve)(process.env.NODE_MODULES_PATH, packageName, "package.json");
+    const nodeModulesPath = String(process.env.NODE_MODULES_PATH ?? "").trim();
+    if (!nodeModulesPath) {
+      throw new Error("NODE_MODULES_PATH is not configured");
+    }
+    const packageFile = (0, import_path.resolve)(nodeModulesPath, packageName, "package.json");
     if (!await import_fs_extra.default.exists(packageFile)) {
       throw new Error(`Cannot find plugin '${nameOrPkg}'`);
     }
@@ -158,9 +181,7 @@ const _PluginManager = class _PluginManager {
    * @internal
    */
   static getPluginPkgPrefix() {
-    return (process.env.PLUGIN_PACKAGE_PREFIX || "@nocobase/plugin-,@nocobase/preset-,@nocobase/plugin-pro-").split(
-      ","
-    );
+    return (0, import_plugin_package.getPluginPackagePrefixes)();
   }
   /**
    * @internal
@@ -215,32 +236,10 @@ const _PluginManager = class _PluginManager {
     if (this.parsedNames[nameOrPkg]) {
       return this.parsedNames[nameOrPkg];
     }
-    if (nameOrPkg.startsWith("@nocobase/plugin-")) {
-      this.parsedNames[nameOrPkg] = {
-        packageName: nameOrPkg,
-        name: nameOrPkg.replace("@nocobase/plugin-", "")
-      };
-      return this.parsedNames[nameOrPkg];
-    }
-    if (nameOrPkg.startsWith("@nocobase/preset-")) {
-      this.parsedNames[nameOrPkg] = {
-        packageName: nameOrPkg,
-        name: nameOrPkg.replace("@nocobase/preset-", "")
-      };
-      return this.parsedNames[nameOrPkg];
-    }
-    const exists = /* @__PURE__ */ __name(async (name, isPreset = false) => {
-      return import_fs_extra.default.exists(
-        (0, import_path.resolve)(process.env.NODE_MODULES_PATH, `@nocobase/${isPreset ? "preset" : "plugin"}-${name}`, "package.json")
-      );
-    }, "exists");
-    if (await exists(nameOrPkg)) {
-      this.parsedNames[nameOrPkg] = { name: nameOrPkg, packageName: `@nocobase/plugin-${nameOrPkg}` };
-    } else if (await exists(nameOrPkg, true)) {
-      this.parsedNames[nameOrPkg] = { name: nameOrPkg, packageName: `@nocobase/preset-${nameOrPkg}` };
-    } else {
-      this.parsedNames[nameOrPkg] = { name: nameOrPkg, packageName: nameOrPkg };
-    }
+    this.parsedNames[nameOrPkg] = await (0, import_plugin_package.parsePluginName)(nameOrPkg, {
+      nodeModulesPath: process.env.NODE_MODULES_PATH,
+      pluginPackagePrefixes: this.getPluginPkgPrefix()
+    });
     return this.parsedNames[nameOrPkg];
   }
   addPreset(plugin, options = {}) {
@@ -279,69 +278,46 @@ const _PluginManager = class _PluginManager {
   }
   /* istanbul ignore next -- @preserve */
   async create(pluginName, options) {
-    const createPlugin = /* @__PURE__ */ __name(async (name2) => {
-      const pluginDir = (0, import_path.resolve)(process.cwd(), "packages/plugins", name2);
+    const createPlugin = /* @__PURE__ */ __name(async (name) => {
+      const pluginDir = (0, import_path.resolve)(process.cwd(), "packages/plugins", name);
       if (options == null ? void 0 : options.forceRecreate) {
         await import_fs_extra.default.rm(pluginDir, { recursive: true, force: true });
       }
-      const { PluginGenerator } = require("@nocobase/cli/src/plugin-generator");
+      const { PluginGenerator } = require("@nocobase/cli-v1/src/plugin-generator");
       const generator = new PluginGenerator({
         cwd: process.cwd(),
         args: {},
         context: {
-          name: name2
+          name
         }
       });
       await generator.run();
     }, "createPlugin");
     await createPlugin(pluginName);
     this.app.log.info("attempt to add the plugin to the app");
-    const { name, packageName } = await _PluginManager.parseName(pluginName);
-    const json = await _PluginManager.getPackageJson(packageName);
-    this.app.log.info(`add plugin [${packageName}]`, {
-      name,
-      packageName,
-      version: json.version
-    });
-    await (0, import_helper.tsxRerunning)();
   }
-  async add(plugin, options = {}, insert = false, isUpgrade = false) {
+  async addOrThrow(plugin, options = {}, insert = false, isUpgrade = false) {
     if (!isUpgrade && this.has(plugin)) {
       const name = typeof plugin === "string" ? plugin : plugin.name;
-      this.app.log.warn(`plugin [${name}] added`);
-      return;
+      throw new Error(`plugin [${name}] already added`);
     }
     if (!options.name && typeof plugin === "string") {
       options.name = plugin;
     }
-    try {
-      if (typeof plugin === "string" && options.name && !options.packageName) {
-        const packageName = await _PluginManager.getPackageName(options.name);
-        if (packageName) {
-          options["packageName"] = packageName;
-        }
-      }
-      if (options.packageName) {
-        const packageJson = await _PluginManager.getPackageJson(options.packageName);
-        options["packageJson"] = packageJson;
-        options["version"] = packageJson.version;
+    if (typeof plugin === "string" && options.name && !options.packageName) {
+      const packageName = await _PluginManager.getPackageName(options.name);
+      if (packageName) {
+        options["packageName"] = packageName;
       }
-    } catch (error) {
-      this.app.log.error(error);
-      console.error(error);
     }
-    this.app.log.trace(`adding plugin [${options.name}]`, {
-      method: "add",
-      submodule: "plugin-manager",
-      name: options.name,
-      options
-    });
-    let P;
-    try {
-      P = await _PluginManager.resolvePlugin(options.packageName || plugin, isUpgrade, !!options.packageName);
-    } catch (error) {
-      this.app.log.warn("plugin not found", error);
-      return;
+    if (options.packageName) {
+      const packageJson = await _PluginManager.getPackageJson(options.packageName);
+      options["packageJson"] = packageJson;
+      options["version"] = packageJson.version;
+    }
+    const P = await _PluginManager.resolvePlugin(options.packageName || plugin, isUpgrade, !!options.packageName);
+    if (!P) {
+      throw new Error(`plugin [${(options == null ? void 0 : options.name) || "unknown"}] load error`);
     }
     const instance = new P((0, import_helper.createAppProxy)(this.app), options);
     this.pluginInstances.set(P, instance);
@@ -352,12 +328,13 @@ const _PluginManager = class _PluginManager {
       this.pluginAliases.set(options.packageName, instance);
     }
     await instance.afterAdd();
-    this.app.log.trace(`added plugin [${options.name}]`, {
-      method: "add",
-      submodule: "plugin-manager",
-      name: instance.name,
-      options: instance.options
-    });
+  }
+  async add(plugin, options = {}, insert = false, isUpgrade = false) {
+    try {
+      await this.addOrThrow(plugin, options, insert, isUpgrade);
+    } catch (error) {
+      this.app.log.error(error);
+    }
   }
   /**
    * @internal
@@ -528,7 +505,7 @@ const _PluginManager = class _PluginManager {
           added[pluginName] = true;
           continue;
         }
-        await this.add(pluginName);
+        await this.addOrThrow(pluginName);
       }
       for (const name of pluginNames) {
         const { name: pluginName } = await _PluginManager.parseName(name);
@@ -771,7 +748,7 @@ const _PluginManager = class _PluginManager {
       if (process.env.VITEST) {
         return;
       }
-      const file = (0, import_path.resolve)(process.cwd(), "storage/.upgrading");
+      const file = (0, import_utils.storagePathJoin)(".upgrading");
       this.app.log.debug("pending upgrade");
       await import_fs_extra.default.writeFile(file, "upgrading");
     }, "writeFile");
@@ -856,7 +833,7 @@ const _PluginManager = class _PluginManager {
         });
         return;
       }
-      const file = (0, import_path.resolve)(process.cwd(), "storage/app-upgrading");
+      const file = (0, import_utils.storagePathJoin)("app-upgrading");
       await import_fs_extra.default.writeFile(file, "", "utf-8");
       await (0, import_helper.tsxRerunning)();
       await (0, import_execa.default)("yarn", ["nocobase", "pm2-restart"], {
@@ -1121,7 +1098,8 @@ const _PluginManager = class _PluginManager {
   }
 };
 __name(_PluginManager, "PluginManager");
-__publicField(_PluginManager, "checkAndGetCompatible", import_utils2.checkAndGetCompatible);
+__publicField(_PluginManager, "compatibleCache", /* @__PURE__ */ new Map());
+__publicField(_PluginManager, "compatiblePending", /* @__PURE__ */ new Map());
 __publicField(_PluginManager, "parsedNames", {});
 let PluginManager = _PluginManager;
 var plugin_manager_default = PluginManager;

package/lib/plugin-manager/utils.d.ts

@@ -9,6 +9,7 @@
 import { AxiosRequestConfig } from 'axios';
 import { PluginManagerRepository } from './plugin-manager-repository';
 import { PluginData } from './types';
+import Application from '../application';
 /**
  * get temp dir
  *
@@ -16,7 +17,8 @@ import { PluginData } from './types';
  * getTempDir() => '/tmp/nocobase'
  */
 export declare function getTempDir(): Promise<string>;
-export declare function getPluginStoragePath(): string;
+export declare function assertSafePluginPackageName(packageName: string): void;
+export declare function resolveSafeChildPath(baseDir: string, child: string): string;
 export declare function getLocalPluginPackagesPathArr(): string[];
 export declare function getStoragePluginDir(packageName: string): string;
 export declare function getLocalPluginDir(packageDirBasename: string): string;
@@ -112,4 +114,10 @@ export declare function checkAndGetCompatible(packageName: string): Promise<{
     depsCompatible: DepCompatible[];
 }>;
 export declare function getPluginBasePath(packageName: string): Promise<string>;
+export declare function pmListSummary(app: Application): Promise<{
+    displayName: any;
+    packageName: any;
+    enabled: boolean;
+    description: any;
+}[]>;
 export {};