@nocobase/server 2.1.0-alpha.4 → 2.1.0-alpha.40

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
    */
@@ -129,7 +155,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}'`);
     }
@@ -271,69 +301,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);
@@ -344,12 +351,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 +528,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 +557,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 +582,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 +655,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 +771,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 +856,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 +1121,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 {};

package/lib/plugin-manager/utils.js

@@ -37,6 +37,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  assertSafePluginPackageName: () => assertSafePluginPackageName,
   checkAndGetCompatible: () => checkAndGetCompatible,
   checkCompatible: () => checkCompatible,
   copyTempPackageToStorageAndLinkToNodeModules: () => copyTempPackageToStorageAndLinkToNodeModules,
@@ -59,18 +60,19 @@ __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,
   removeTmpDir: () => removeTmpDir,
   requireModule: () => requireModule,
   requireNoCache: () => requireNoCache,
+  resolveSafeChildPath: () => resolveSafeChildPath,
   updatePluginByCompressedFileUrl: () => updatePluginByCompressedFileUrl
 });
 module.exports = __toCommonJS(utils_exports);
@@ -88,17 +90,42 @@ 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);
+function assertSafePluginPackageName(packageName) {
+  if (!packageName || typeof packageName !== "string") {
+    throw new Error("Invalid plugin package name");
+  }
+  if (packageName.includes("\0")) {
+    throw new Error("Invalid plugin package name");
+  }
+  if (import_path.default.isAbsolute(packageName)) {
+    throw new Error("Invalid plugin package name");
+  }
+  if (packageName.includes("..") || packageName.includes("\\")) {
+    throw new Error("Invalid plugin package name");
+  }
+  const valid = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i.test(packageName);
+  if (!valid) {
+    throw new Error("Invalid plugin package name");
+  }
+}
+__name(assertSafePluginPackageName, "assertSafePluginPackageName");
+function resolveSafeChildPath(baseDir, child) {
+  const resolvedBase = import_path.default.resolve(baseDir);
+  const resolvedTarget = import_path.default.resolve(baseDir, child);
+  if (resolvedTarget !== resolvedBase && !resolvedTarget.startsWith(`${resolvedBase}${import_path.default.sep}`)) {
+    throw new Error("Path traversal detected");
+  }
+  return resolvedTarget;
 }
-__name(getPluginStoragePath, "getPluginStoragePath");
+__name(resolveSafeChildPath, "resolveSafeChildPath");
 function getLocalPluginPackagesPathArr() {
   const pluginPackagesPathArr = process.env.PLUGIN_PATH || import_constants.DEFAULT_PLUGIN_PATH;
   return pluginPackagesPathArr.split(",").map((pluginPackagesPath) => {
@@ -108,8 +135,9 @@ function getLocalPluginPackagesPathArr() {
 }
 __name(getLocalPluginPackagesPathArr, "getLocalPluginPackagesPathArr");
 function getStoragePluginDir(packageName) {
-  const pluginStoragePath = getPluginStoragePath();
-  return import_path.default.join(pluginStoragePath, packageName);
+  const pluginStoragePath = (0, import_utils.resolvePluginStoragePath)();
+  assertSafePluginPackageName(packageName);
+  return resolveSafeChildPath(pluginStoragePath, packageName);
 }
 __name(getStoragePluginDir, "getStoragePluginDir");
 function getLocalPluginDir(packageDirBasename) {
@@ -121,7 +149,8 @@ function getLocalPluginDir(packageDirBasename) {
 }
 __name(getLocalPluginDir, "getLocalPluginDir");
 function getNodeModulesPluginDir(packageName) {
-  return import_path.default.join(process.env.NODE_MODULES_PATH, packageName);
+  assertSafePluginPackageName(packageName);
+  return resolveSafeChildPath(process.env.NODE_MODULES_PATH, packageName);
 }
 __name(getNodeModulesPluginDir, "getNodeModulesPluginDir");
 function getAuthorizationHeaders(registry, authToken) {
@@ -340,7 +369,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,8 +554,36 @@ 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 = {
+  assertSafePluginPackageName,
   checkAndGetCompatible,
   checkCompatible,
   copyTempPackageToStorageAndLinkToNodeModules,
@@ -549,17 +606,18 @@ __name(getPluginBasePath, "getPluginBasePath");
   getPackagesFromFiles,
   getPluginBasePath,
   getPluginInfoByNpm,
-  getPluginStoragePath,
   getServerPackages,
   getStoragePluginDir,
   getTempDir,
   isNotBuiltinModule,
   isValidPackageName,
+  pmListSummary,
   readJSONFileContent,
   removePluginPackage,
   removeRequireCache,
   removeTmpDir,
   requireModule,
   requireNoCache,
+  resolveSafeChildPath,
   updatePluginByCompressedFileUrl
 });

package/lib/plugin.js

@@ -206,6 +206,7 @@ const _Plugin = class _Plugin {
       return;
     }
     const toolsLoader = new import_ai.ToolsLoader(this.ai, {
+      pluginName: this.getName(),
       scan: {
         basePath,
         pattern: ["**/tools/**/*.ts", "**/tools/**/*.js", "!**/tools/**/*.d.ts", "**/tools/**/*/description.md"]
@@ -213,6 +214,37 @@ const _Plugin = class _Plugin {
       log: this.log
     });
     await toolsLoader.load();
+    const mcpLoader = new import_ai.MCPLoader(this.ai, {
+      pluginName: this.getName(),
+      scan: {
+        basePath,
+        pattern: ["mcp/*.ts", "mcp/*.js", "!mcp/*.d.ts"]
+      },
+      log: this.log
+    });
+    await mcpLoader.load();
+    const skillsLoader = new import_ai.SkillsLoader(this.ai, {
+      pluginName: this.getName(),
+      scan: { basePath, pattern: ["**/skills/**/SKILLS.md"] },
+      log: this.log
+    });
+    await skillsLoader.load();
+    const employeeLoader = new import_ai.AIEmployeeLoader(this.ai, {
+      pluginName: this.getName(),
+      scan: {
+        basePath,
+        pattern: [
+          "**/ai-employees/*.ts",
+          "**/ai-employees/*/index.ts",
+          "**/ai-employees/*.js",
+          "**/ai-employees/*/index.js",
+          "**/ai-employees/*/prompt.md",
+          "!**/ai-employees/**/*.d.ts"
+        ]
+      },
+      log: this.log
+    });
+    await employeeLoader.load();
   }
   /**
    * @deprecated
@@ -234,6 +266,18 @@ const _Plugin = class _Plugin {
         ...this.options
       };
     }
+    const langMap = {
+      "zh-CN": "cn/",
+      "en-US": "",
+      "ja-JP": "ja/",
+      "es-ES": "es/",
+      "pt-PT": "pt/",
+      "de-DE": "de",
+      "fr-FR": "fr/"
+    };
+    if (packageName.startsWith("@nocobase/plugin-")) {
+      packageJson.homepage = `https://v2.docs.nocobase.com/${langMap[locale] || ""}plugins/${packageName}`;
+    }
     const results = {
       ...this.options,
       keywords: packageJson.keywords,
@@ -241,7 +285,7 @@ const _Plugin = class _Plugin {
       changelogUrl: (0, import_plugin_manager.getExposeChangelogUrl)(packageName),
       displayName: packageJson[`displayName.${locale}`] || packageJson.displayName || name,
       description: packageJson[`description.${locale}`] || packageJson.description,
-      homepage: packageJson[`homepage.${locale}`] || packageJson.homepage
+      homepage: packageJson.homepage
     };
     if (!options.withOutOpenFile) {
       const file = await import_fs.default.promises.realpath(
@@ -252,7 +296,7 @@ const _Plugin = class _Plugin {
         ...await (0, import_utils2.checkAndGetCompatible)(packageName),
         lastUpdated: (await import_fs.default.promises.stat(file)).ctime,
         file,
-        updatable: file.startsWith(process.env.PLUGIN_STORAGE_PATH)
+        updatable: file.startsWith((0, import_utils.resolvePluginStoragePath)())
       };
     }
     return results;

package/lib/pub-sub-manager/handler-manager.d.ts

@@ -29,6 +29,7 @@ export declare class HandlerManager {
     set(channel: string, callback: any, options: PubSubManagerSubscribeOptions): (wrappedMessage: any) => Promise<void>;
     get(channel: string, callback: any): any;
     delete(channel: string, callback: any): any;
+    cancelPendingDebounce(): void;
     reset(): void;
     each(callback: any): Promise<void>;
 }

package/lib/pub-sub-manager/handler-manager.js

@@ -129,7 +129,18 @@ const _HandlerManager = class _HandlerManager {
     headlerMap.delete(callback);
     return headler;
   }
+  cancelPendingDebounce() {
+    if (this.uniqueMessageHandlers) {
+      for (const handler of this.uniqueMessageHandlers.values()) {
+        if (typeof (handler == null ? void 0 : handler.cancel) === "function") {
+          handler.cancel();
+        }
+      }
+      this.uniqueMessageHandlers.clear();
+    }
+  }
   reset() {
+    this.cancelPendingDebounce();
     this.handlers = /* @__PURE__ */ new Map();
     this.uniqueMessageHandlers = /* @__PURE__ */ new Map();
   }

package/lib/pub-sub-manager/pub-sub-manager.js

@@ -38,7 +38,7 @@ const createPubSubManager = /* @__PURE__ */ __name((app, options) => {
   app.on("afterStart", async () => {
     await pubSubManager.connect();
   });
-  app.on("afterStop", async () => {
+  app.on("beforeStop", async () => {
     await pubSubManager.close();
   });
   return pubSubManager;
@@ -77,6 +77,7 @@ const _PubSubManager = class _PubSubManager {
     });
   }
   async close() {
+    this.handlerManager.cancelPendingDebounce();
     if (!this.adapter) {
       return;
     }

package/lib/swagger/app.d.ts

@@ -0,0 +1,102 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    readonly '/app:getLang': {
+        readonly get: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Get the current application language";
+            readonly description: "Return the current locale used by the server.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                    readonly content: {
+                        readonly 'application/json': {
+                            readonly schema: {
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly '/app:getInfo': {
+        readonly get: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Get application metadata";
+            readonly description: "Return basic application information, including version and environment-related metadata.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                    readonly content: {
+                        readonly 'application/json': {
+                            readonly schema: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly '/app:getPlugins': {
+        readonly get: {
+            readonly tags: readonly ["app"];
+            readonly summary: "List loaded plugins";
+            readonly description: "Return plugin metadata for the current application runtime.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                    readonly content: {
+                        readonly 'application/json': {
+                            readonly schema: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly additionalProperties: true;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly '/app:restart': {
+        readonly post: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Restart the application";
+            readonly description: "Trigger an application restart asynchronously.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                };
+            };
+        };
+    };
+    readonly '/app:clearCache': {
+        readonly post: {
+            readonly tags: readonly ["app"];
+            readonly summary: "Clear application cache";
+            readonly description: "Clear server-side caches used by the current application instance.";
+            readonly parameters: readonly [];
+            readonly responses: {
+                readonly 200: {
+                    readonly description: "OK";
+                };
+            };
+        };
+    };
+};
+export default _default;