@nocobase/server 2.1.0-beta.2 → 2.1.0-beta.21

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

@@ -39,45 +39,136 @@ 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_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"
+};
 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 cacheKey = this.getCacheKey(packageName, lane);
+    if (!this.items[cacheKey]) {
+      this.items[cacheKey] = await this.fetch(packageName, lane);
     }
-    return this.items[packageName];
+    return this.items[cacheKey];
   }
-  static async fetch(packageName) {
-    const PLUGIN_CLIENT_ENTRY_FILE = "dist/client/index.js";
+  static async hasClientEntry(packageName, lane) {
     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);
-        t = `?t=${fsState.mtime.getTime()}`;
-      }
-      const cdnBaseUrl = process.env.CDN_BASE_URL.replace(/\/+$/, "");
-      const url = `${cdnBaseUrl}${"/static/plugins/"}${packageName}/${PLUGIN_CLIENT_ENTRY_FILE}${t}`;
-      return url;
+    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;
+        }
+      } 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) {
+      arr.push({
+        name,
+        packageName,
+        options,
+        url
+      });
+    }
+  }
+  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) {
@@ -93,12 +184,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) {
@@ -108,6 +199,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 = [];
@@ -122,12 +216,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;
       }
@@ -145,23 +239,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();
     },
@@ -176,6 +287,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");
@@ -183,29 +299,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) {
@@ -221,3 +319,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

@@ -58,6 +58,14 @@ 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_utils2 = require("./utils");
+const _PluginLoadError = class _PluginLoadError extends Error {
+  constructor(pluginName) {
+    super(`${pluginName} plugin load error`);
+    this.name = "PluginLoadError";
+  }
+};
+__name(_PluginLoadError, "PluginLoadError");
+let PluginLoadError = _PluginLoadError;
 const sleep = /* @__PURE__ */ __name(async (timeout = 0) => {
   return new Promise((resolve2) => {
     setTimeout(resolve2, timeout);
@@ -82,6 +90,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:*"]
@@ -92,6 +101,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
    */
@@ -297,43 +323,28 @@ const _PluginManager = class _PluginManager {
     });
     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 (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;
-      }
-    } 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);
@@ -344,12 +355,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
@@ -520,13 +532,13 @@ 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);
         const plugin = this.get(pluginName);
         if (!plugin) {
-          throw new Error(`${pluginName} plugin does not exist`);
+          throw new PluginLoadError(pluginName);
         }
         if (added[pluginName]) {
           continue;
@@ -549,7 +561,7 @@ const _PluginManager = class _PluginManager {
         const { name: pluginName } = await _PluginManager.parseName(name);
         const plugin = this.get(pluginName);
         if (!plugin) {
-          throw new Error(`${pluginName} plugin does not exist`);
+          throw new PluginLoadError(pluginName);
         }
         if (added[pluginName]) {
           continue;
@@ -574,7 +586,7 @@ const _PluginManager = class _PluginManager {
       const { name: pluginName } = await _PluginManager.parseName(name);
       const plugin = this.get(pluginName);
       if (!plugin) {
-        throw new Error(`${pluginName} plugin does not exist`);
+        throw new PluginLoadError(pluginName);
       }
       if (plugin.enabled) {
         continue;
@@ -647,7 +659,7 @@ const _PluginManager = class _PluginManager {
       const { name: pluginName } = await _PluginManager.parseName(name2);
       const plugin = this.get(pluginName);
       if (!plugin) {
-        throw new Error(`${pluginName} plugin does not exist`);
+        throw new PluginLoadError(pluginName);
       }
       if (!plugin.enabled) {
         continue;
@@ -763,7 +775,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");
@@ -848,7 +860,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"], {
@@ -1113,7 +1125,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,6 @@ import { PluginData } from './types';
  * getTempDir() => '/tmp/nocobase'
  */
 export declare function getTempDir(): Promise<string>;
-export declare function getPluginStoragePath(): string;
 export declare function getLocalPluginPackagesPathArr(): string[];
 export declare function getStoragePluginDir(packageName: string): string;
 export declare function getLocalPluginDir(packageDirBasename: string): string;
@@ -112,4 +112,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 {};

package/lib/plugin-manager/utils.js

@@ -59,12 +59,12 @@ __export(utils_exports, {
   getPackagesFromFiles: () => getPackagesFromFiles,
   getPluginBasePath: () => getPluginBasePath,
   getPluginInfoByNpm: () => getPluginInfoByNpm,
-  getPluginStoragePath: () => getPluginStoragePath,
   getServerPackages: () => getServerPackages,
   getStoragePluginDir: () => getStoragePluginDir,
   getTempDir: () => getTempDir,
   isNotBuiltinModule: () => isNotBuiltinModule,
   isValidPackageName: () => isValidPackageName,
+  pmListSummary: () => pmListSummary,
   readJSONFileContent: () => readJSONFileContent,
   removePluginPackage: () => removePluginPackage,
   removeRequireCache: () => removeRequireCache,
@@ -88,17 +88,14 @@ var import_semver = __toESM(require("semver"));
 var import_clientStaticUtils = require("./clientStaticUtils");
 var import_constants = require("./constants");
 var import_deps = __toESM(require("./deps"));
+var import_findPackageNames = require("./findPackageNames");
+var import_plugin_manager = __toESM(require("./plugin-manager"));
 /* istanbul ignore next -- @preserve */
 async function getTempDir() {
   const temporaryDirectory = await import_fs_extra.default.realpath(import_os.default.tmpdir());
   return import_path.default.join(temporaryDirectory, import_constants.APP_NAME);
 }
 __name(getTempDir, "getTempDir");
-function getPluginStoragePath() {
-  const pluginStoragePath = process.env.PLUGIN_STORAGE_PATH || import_constants.DEFAULT_PLUGIN_STORAGE_PATH;
-  return import_path.default.isAbsolute(pluginStoragePath) ? pluginStoragePath : import_path.default.join(process.cwd(), pluginStoragePath);
-}
-__name(getPluginStoragePath, "getPluginStoragePath");
 function getLocalPluginPackagesPathArr() {
   const pluginPackagesPathArr = process.env.PLUGIN_PATH || import_constants.DEFAULT_PLUGIN_PATH;
   return pluginPackagesPathArr.split(",").map((pluginPackagesPath) => {
@@ -108,7 +105,7 @@ function getLocalPluginPackagesPathArr() {
 }
 __name(getLocalPluginPackagesPathArr, "getLocalPluginPackagesPathArr");
 function getStoragePluginDir(packageName) {
-  const pluginStoragePath = getPluginStoragePath();
+  const pluginStoragePath = (0, import_utils.resolvePluginStoragePath)();
   return import_path.default.join(pluginStoragePath, packageName);
 }
 __name(getStoragePluginDir, "getStoragePluginDir");
@@ -340,7 +337,7 @@ async function updatePluginByCompressedFileUrl(options) {
   });
   if (!instance) {
     await removeTmpDir(tempFile, tempPackageContentDir);
-    throw new Error(`plugin ${packageName} does not exist`);
+    throw new Error(`${packageName} does not exist`);
   }
   const { packageDir } = await copyTempPackageToStorageAndLinkToNodeModules(
     tempFile,
@@ -525,6 +522,33 @@ async function getPluginBasePath(packageName) {
   return import_path.default.dirname(import_path.default.dirname(file));
 }
 __name(getPluginBasePath, "getPluginBasePath");
+async function pmListSummary(app) {
+  const plugins1 = await (0, import_findPackageNames.findBuiltInPlugins)();
+  const plugins2 = await (0, import_findPackageNames.findLocalPlugins)();
+  let enabledPlugins = [];
+  try {
+    enabledPlugins = (await app.pm.repository.find({
+      filter: {
+        enabled: true
+      }
+    })).map((item) => item.packageName);
+  } catch (error) {
+  }
+  const items = await Promise.all(
+    [...plugins1, ...plugins2].map(async (name) => {
+      const item = await import_plugin_manager.default.parseName(name);
+      const json = await import_plugin_manager.default.getPackageJson(item.packageName);
+      return {
+        displayName: json.displayName || name,
+        packageName: item.packageName,
+        enabled: enabledPlugins.includes(item.packageName),
+        description: json.description
+      };
+    })
+  );
+  return items;
+}
+__name(pmListSummary, "pmListSummary");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkAndGetCompatible,
@@ -549,12 +573,12 @@ __name(getPluginBasePath, "getPluginBasePath");
   getPackagesFromFiles,
   getPluginBasePath,
   getPluginInfoByNpm,
-  getPluginStoragePath,
   getServerPackages,
   getStoragePluginDir,
   getTempDir,
   isNotBuiltinModule,
   isValidPackageName,
+  pmListSummary,
   readJSONFileContent,
   removePluginPackage,
   removeRequireCache,