@nocobase/server 2.1.0-alpha.2 → 2.1.0-alpha.20

package/lib/plugin.js

@@ -213,6 +213,34 @@ const _Plugin = class _Plugin {
       log: this.log
     });
     await toolsLoader.load();
+    const mcpLoader = new import_ai.MCPLoader(this.ai, {
+      scan: {
+        basePath,
+        pattern: ["mcp/*.ts", "mcp/*.js", "!mcp/*.d.ts"]
+      },
+      log: this.log
+    });
+    await mcpLoader.load();
+    const skillsLoader = new import_ai.SkillsLoader(this.ai, {
+      scan: { basePath, pattern: ["**/skills/**/SKILLS.md"] },
+      log: this.log
+    });
+    await skillsLoader.load();
+    const employeeLoader = new import_ai.AIEmployeeLoader(this.ai, {
+      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 +262,19 @@ const _Plugin = class _Plugin {
         ...this.options
       };
     }
+    const langMap = {
+      "zh-CN": "cn/",
+      "en-US": "",
+      "ja-JP": "ja/",
+      "ko-KR": "ko/",
+      "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 +282,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 +293,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;

package/lib/swagger/app.js

@@ -0,0 +1,124 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var app_exports = {};
+__export(app_exports, {
+  default: () => app_default
+});
+module.exports = __toCommonJS(app_exports);
+var app_default = {
+  "/app:getLang": {
+    get: {
+      tags: ["app"],
+      summary: "Get the current application language",
+      description: "Return the current locale used by the server.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "string"
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/app:getInfo": {
+    get: {
+      tags: ["app"],
+      summary: "Get application metadata",
+      description: "Return basic application information, including version and environment-related metadata.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                additionalProperties: true
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/app:getPlugins": {
+    get: {
+      tags: ["app"],
+      summary: "List loaded plugins",
+      description: "Return plugin metadata for the current application runtime.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "array",
+                items: {
+                  type: "object",
+                  additionalProperties: true
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "/app:restart": {
+    post: {
+      tags: ["app"],
+      summary: "Restart the application",
+      description: "Trigger an application restart asynchronously.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK"
+        }
+      }
+    }
+  },
+  "/app:clearCache": {
+    post: {
+      tags: ["app"],
+      summary: "Clear application cache",
+      description: "Clear server-side caches used by the current application instance.",
+      parameters: [],
+      responses: {
+        200: {
+          description: "OK"
+        }
+      }
+    }
+  }
+};

package/lib/swagger/base.d.ts

@@ -0,0 +1,244 @@
+/**
+ * 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 openapi: "3.0.2";
+    readonly info: {
+        readonly title: "NocoBase API - Core";
+    };
+    readonly tags: readonly [{
+        readonly name: "$collection";
+        readonly description: "Data table";
+    }, {
+        readonly name: "$collection.$oneToOneAssociation";
+        readonly description: "One to one relationship";
+    }, {
+        readonly name: "$collection.$manyToOneAssociation";
+        readonly description: "Many to one relationship";
+    }, {
+        readonly name: "$collection.$oneToManyAssociation";
+        readonly description: "One to many relationship";
+    }, {
+        readonly name: "$collection.$manyToManyAssociation";
+        readonly description: "Many to many relationship";
+    }, {
+        readonly name: "app";
+        readonly description: "app";
+    }, {
+        readonly name: "pm";
+        readonly description: "pm";
+    }];
+    readonly components: {
+        readonly parameters: {
+            readonly collectionName: {
+                readonly required: true;
+                readonly name: "collectionName";
+                readonly in: "path";
+                readonly description: "Collection name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly collectionIndex: {
+                readonly required: true;
+                readonly name: "collectionIndex";
+                readonly in: "path";
+                readonly description: "Collection index";
+                readonly schema: {
+                    readonly type: "integer";
+                    readonly format: "int64";
+                };
+            };
+            readonly oneToOneAssociation: {
+                readonly required: true;
+                readonly name: "oneToOneAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly manyToOneAssociation: {
+                readonly required: true;
+                readonly name: "manyToOneAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly oneToManyAssociation: {
+                readonly required: true;
+                readonly name: "oneToManyAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly manyToManyAssociation: {
+                readonly required: true;
+                readonly name: "manyToManyAssociation";
+                readonly in: "path";
+                readonly description: "Association name";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly page: {
+                readonly name: "page";
+                readonly in: "query";
+                readonly description: "page number";
+                readonly required: false;
+                readonly schema: {
+                    readonly type: "integer";
+                };
+            };
+            readonly pageSize: {
+                readonly name: "pageSize";
+                readonly in: "query";
+                readonly description: "page size";
+                readonly required: false;
+                readonly schema: {
+                    readonly type: "integer";
+                };
+            };
+            readonly filterByTk: {
+                readonly name: "filterByTk";
+                readonly in: "query";
+                readonly description: "filter by TK(default by ID)";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly filterByTks: {
+                readonly name: "filterByTks";
+                readonly in: "query";
+                readonly description: "filter by TKs(default by ID), example: `1,2,3`";
+                readonly schema: {
+                    readonly type: "string";
+                };
+            };
+            readonly filter: {
+                readonly name: "filter";
+                readonly in: "query";
+                readonly description: "filter items";
+                readonly content: {
+                    readonly 'application/json': {
+                        readonly schema: {
+                            readonly type: "object";
+                        };
+                    };
+                };
+            };
+            readonly sort: {
+                readonly name: "sort";
+                readonly in: "query";
+                readonly description: "sort items by fields, example: `-field1,-field2,field3`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["-id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "-id,createdAt";
+                    }];
+                };
+            };
+            readonly fields: {
+                readonly name: "fields";
+                readonly in: "query";
+                readonly description: "select fields, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly except: {
+                readonly name: "except";
+                readonly in: "query";
+                readonly description: "except fields in results, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly appends: {
+                readonly name: "appends";
+                readonly in: "query";
+                readonly description: "append associations in results, example: `assoc1,assoc2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly whitelist: {
+                readonly name: "whitelist";
+                readonly in: "query";
+                readonly description: "whitelist for fields changes, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+            readonly blacklist: {
+                readonly name: "blacklist";
+                readonly in: "query";
+                readonly description: "blacklist for fields changes, example: `field1,field2`";
+                readonly schema: {
+                    readonly oneOf: readonly [{
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly example: readonly ["id", "createdAt"];
+                    }, {
+                        readonly type: "string";
+                        readonly example: "id,createdAt";
+                    }];
+                };
+            };
+        };
+    };
+};
+export default _default;