@timmy_hu/plugin-middleware 1.0.0

package/index.js

@@ -0,0 +1,519 @@
+require("reflect-metadata");
+const { Injectable } = require("@nestjs/common");
+const { AgentMiddlewareStrategy } = require("@xpert-ai/plugin-sdk");
+const { tool } = require("@langchain/core/tools");
+const { z } = require("zod");
+
+const MIDDLEWARE_PROVIDER = "PluginMiddleware";
+
+class PluginMiddleware {
+  constructor() {
+    this.meta = {
+      name: MIDDLEWARE_PROVIDER,
+      label: {
+        en_US: "Plugin Middleware Manager",
+        zh_Hans: "插件中间件管理器"
+      },
+      description: {
+        en_US: "Discovers all middleware-type plugins and provides dynamic on-demand loading, unloading, and status query tools for agent orchestration.",
+        zh_Hans: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。"
+      },
+      configSchema: {
+        type: "object",
+        properties: {
+          platformUrl: {
+            type: "string",
+            title: {
+              en_US: "Platform URL",
+              zh_Hans: "平台地址"
+            },
+            description: "XpertAI platform base URL for plugin discovery API",
+            default: "http://10.161.48.53:3300"
+          },
+          organizationId: {
+            type: "string",
+            title: {
+              en_US: "Organization ID",
+              zh_Hans: "组织 ID"
+            },
+            description: "Organization ID for scoped plugin queries"
+          },
+          autoDiscover: {
+            type: "boolean",
+            title: {
+              en_US: "Auto Discover",
+              zh_Hans: "自动发现"
+            },
+            description: "Whether to automatically discover available middleware plugins on startup",
+            default: true
+          },
+          cacheTtlSeconds: {
+            type: "number",
+            title: {
+              en_US: "Cache TTL (seconds)",
+              zh_Hans: "缓存有效期（秒）"
+            },
+            description: "How long to cache the discovered plugin list before refreshing",
+            default: 300
+          }
+        },
+        required: ["platformUrl"]
+      }
+    };
+  }
+
+  createMiddleware(options = {}, context = {}) {
+    const platformUrl = options.platformUrl || "http://10.161.48.53:3300";
+    const organizationId = options.organizationId || "";
+    const autoDiscover = options.autoDiscover !== false;
+    const cacheTtlSeconds = options.cacheTtlSeconds || 300;
+
+    // In-memory registry for discovered middleware plugins
+    const registry = {
+      plugins: new Map(),
+      loadedPlugins: new Map(),
+      lastRefresh: null,
+      cacheTtl: cacheTtlSeconds * 1000
+    };
+
+    // Helper: fetch middleware plugins from platform API
+    async function fetchMiddlewarePlugins() {
+      const now = Date.now();
+      if (registry.lastRefresh && (now - registry.lastRefresh) < registry.cacheTtl) {
+        return Array.from(registry.plugins.values());
+      }
+
+      try {
+        const fetch = (await import("node-fetch")).default;
+        const url = `${platformUrl}/api/plugin?category=middleware&organization-id=${encodeURIComponent(organizationId)}`;
+        const resp = await fetch(url, {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+            ...(organizationId ? { "organization-id": organizationId } : {})
+          },
+          timeout: 10000
+        });
+
+        if (!resp.ok) {
+          throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
+        }
+
+        const data = await resp.json();
+        const pluginList = Array.isArray(data) ? data : (data.data || data.items || data.plugins || []);
+
+        registry.plugins.clear();
+        for (const p of pluginList) {
+          const code = p.code || p.name || p.pluginName;
+          if (code) {
+            registry.plugins.set(code, {
+              code,
+              name: p.name || p.displayName || code,
+              version: p.version || "unknown",
+              description: p.description || "",
+              status: p.status || "available",
+              category: p.category || "middleware",
+              loaded: registry.loadedPlugins.has(code)
+            });
+          }
+        }
+
+        registry.lastRefresh = now;
+        return Array.from(registry.plugins.values());
+      } catch (err) {
+        // If API call fails, return cached data or empty list
+        if (registry.plugins.size > 0) {
+          return Array.from(registry.plugins.values());
+        }
+        throw new Error(`Failed to discover middleware plugins: ${err.message}`);
+      }
+    }
+
+    // Tool 1: List all discovered middleware plugins
+    const listMiddlewarePlugins = tool(
+      async (input) => {
+        try {
+          const plugins = await fetchMiddlewarePlugins();
+          const filter = input.filter || "all";
+
+          let filtered = plugins;
+          if (filter === "loaded") {
+            filtered = plugins.filter(p => p.loaded || registry.loadedPlugins.has(p.code));
+          } else if (filter === "available") {
+            filtered = plugins.filter(p => !p.loaded && !registry.loadedPlugins.has(p.code));
+          }
+
+          return {
+            success: true,
+            total: filtered.length,
+            plugins: filtered.map(p => ({
+              code: p.code,
+              name: p.name,
+              version: p.version,
+              description: p.description,
+              status: registry.loadedPlugins.has(p.code) ? "loaded" : "available",
+              loadedAt: registry.loadedPlugins.has(p.code)
+                ? registry.loadedPlugins.get(p.code).loadedAt
+                : null
+            }))
+          };
+        } catch (err) {
+          return {
+            success: false,
+            error: err.message,
+            plugins: []
+          };
+        }
+      },
+      {
+        name: "list_middleware_plugins",
+        description: "列出所有已发现的中间件类型插件，可按加载状态过滤。返回插件编码、名称、版本、描述和当前状态。",
+        schema: z.object({
+          filter: z.enum(["all", "loaded", "available"]).optional().default("all")
+            .describe("过滤条件：all=全部, loaded=已加载, available=可用未加载")
+        })
+      }
+    );
+
+    // Tool 2: Load a specific middleware plugin by code
+    const loadMiddlewarePlugin = tool(
+      async (input) => {
+        const pluginCode = input.pluginCode;
+
+        if (registry.loadedPlugins.has(pluginCode)) {
+          return {
+            success: true,
+            message: `插件 ${pluginCode} 已经处于加载状态`,
+            plugin: {
+              code: pluginCode,
+              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
+              status: "already_loaded"
+            }
+          };
+        }
+
+        // Discover if not yet known
+        const plugins = await fetchMiddlewarePlugins();
+        const target = plugins.find(p => p.code === pluginCode);
+
+        if (!target) {
+          return {
+            success: false,
+            error: `未找到编码为 ${pluginCode} 的中间件插件`,
+            availablePlugins: plugins.map(p => p.code)
+          };
+        }
+
+        try {
+          // Attempt to load via platform API
+          const fetch = (await import("node-fetch")).default;
+          const loadUrl = `${platformUrl}/api/plugin/load`;
+          const resp = await fetch(loadUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...(organizationId ? { "organization-id": organizationId } : {})
+            },
+            body: JSON.stringify({
+              pluginName: target.name || pluginCode,
+              version: target.version,
+              source: "npm"
+            }),
+            timeout: 30000
+          });
+
+          if (!resp.ok) {
+            const errText = await resp.text();
+            throw new Error(`Load API returned ${resp.status}: ${errText}`);
+          }
+
+          const result = await resp.json();
+
+          registry.loadedPlugins.set(pluginCode, {
+            code: pluginCode,
+            name: target.name,
+            version: target.version,
+            loadedAt: new Date().toISOString(),
+            loadResult: result
+          });
+
+          return {
+            success: true,
+            message: `插件 ${pluginCode} 加载成功`,
+            plugin: {
+              code: pluginCode,
+              name: target.name,
+              version: target.version,
+              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
+              status: "loaded"
+            }
+          };
+        } catch (err) {
+          // Even if API call fails, mark as locally loaded for demo/offline scenarios
+          registry.loadedPlugins.set(pluginCode, {
+            code: pluginCode,
+            name: target.name,
+            version: target.version,
+            loadedAt: new Date().toISOString(),
+            loadResult: { offline: true, error: err.message }
+          });
+
+          return {
+            success: true,
+            message: `插件 ${pluginCode} 已标记为加载（离线模式）`,
+            plugin: {
+              code: pluginCode,
+              name: target.name,
+              version: target.version,
+              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
+              status: "loaded_offline",
+              warning: err.message
+            }
+          };
+        }
+      },
+      {
+        name: "load_middleware_plugin",
+        description: "按插件编码动态加载指定的中间件插件。加载后该插件的工具和能力将对智能体可用。",
+        schema: z.object({
+          pluginCode: z.string().min(1).describe("要加载的中间件插件编码，例如 'weather-query' 或 'pg-query-tool'")
+        })
+      }
+    );
+
+    // Tool 3: Unload a specific middleware plugin
+    const unloadMiddlewarePlugin = tool(
+      async (input) => {
+        const pluginCode = input.pluginCode;
+
+        if (!registry.loadedPlugins.has(pluginCode)) {
+          return {
+            success: false,
+            error: `插件 ${pluginCode} 当前未加载，无需卸载`,
+            loadedPlugins: Array.from(registry.loadedPlugins.keys())
+          };
+        }
+
+        try {
+          const fetch = (await import("node-fetch")).default;
+          const unloadUrl = `${platformUrl}/api/plugin/unload`;
+          const resp = await fetch(unloadUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...(organizationId ? { "organization-id": organizationId } : {})
+            },
+            body: JSON.stringify({ pluginCode }),
+            timeout: 15000
+          });
+
+          if (!resp.ok) {
+            const errText = await resp.text();
+            throw new Error(`Unload API returned ${resp.status}: ${errText}`);
+          }
+        } catch (err) {
+          // Continue with local unload even if API fails
+        }
+
+        const removed = registry.loadedPlugins.get(pluginCode);
+        registry.loadedPlugins.delete(pluginCode);
+
+        return {
+          success: true,
+          message: `插件 ${pluginCode} 已卸载`,
+          plugin: {
+            code: pluginCode,
+            name: removed.name,
+            unloadedAt: new Date().toISOString(),
+            status: "unloaded"
+          }
+        };
+      },
+      {
+        name: "unload_middleware_plugin",
+        description: "按插件编码卸载已加载的中间件插件。卸载后该插件的工具将不再对智能体可用。",
+        schema: z.object({
+          pluginCode: z.string().min(1).describe("要卸载的中间件插件编码")
+        })
+      }
+    );
+
+    // Tool 4: Query detailed status of a specific middleware plugin
+    const getMiddlewarePluginStatus = tool(
+      async (input) => {
+        const pluginCode = input.pluginCode;
+        const plugins = await fetchMiddlewarePlugins();
+        const target = plugins.find(p => p.code === pluginCode);
+
+        if (!target) {
+          return {
+            success: false,
+            error: `未找到编码为 ${pluginCode} 的中间件插件`
+          };
+        }
+
+        const loaded = registry.loadedPlugins.has(pluginCode);
+        const loadInfo = loaded ? registry.loadedPlugins.get(pluginCode) : null;
+
+        return {
+          success: true,
+          plugin: {
+            code: target.code,
+            name: target.name,
+            version: target.version,
+            description: target.description,
+            category: target.category,
+            status: loaded ? "loaded" : "available",
+            loadedAt: loadInfo ? loadInfo.loadedAt : null,
+            tools: loaded ? (loadInfo.tools || []) : [],
+            configRequired: target.configRequired || []
+          }
+        };
+      },
+      {
+        name: "get_middleware_plugin_status",
+        description: "查询指定中间件插件的详细状态信息，包括加载状态、版本、描述和可用工具列表。",
+        schema: z.object({
+          pluginCode: z.string().min(1).describe("要查询的中间件插件编码")
+        })
+      }
+    );
+
+    // Tool 5: Refresh the plugin discovery cache
+    const refreshPluginCache = tool(
+      async (input) => {
+        registry.lastRefresh = null;
+        try {
+          const plugins = await fetchMiddlewarePlugins();
+          return {
+            success: true,
+            message: `缓存已刷新，发现 ${plugins.length} 个中间件插件`,
+            total: plugins.length,
+            refreshedAt: new Date().toISOString()
+          };
+        } catch (err) {
+          return {
+            success: false,
+            error: `刷新缓存失败: ${err.message}`
+          };
+        }
+      },
+      {
+        name: "refresh_plugin_cache",
+        description: "刷新中间件插件发现缓存，强制从平台重新获取所有中间件类型插件列表。",
+        schema: z.object({})
+      }
+    );
+
+    // Tool 6: Batch load multiple middleware plugins
+    const batchLoadMiddlewarePlugins = tool(
+      async (input) => {
+        const pluginCodes = input.pluginCodes;
+        const results = [];
+
+        const plugins = await fetchMiddlewarePlugins();
+
+        for (const code of pluginCodes) {
+          if (registry.loadedPlugins.has(code)) {
+            results.push({
+              code,
+              status: "already_loaded",
+              success: true
+            });
+            continue;
+          }
+
+          const target = plugins.find(p => p.code === code);
+          if (!target) {
+            results.push({
+              code,
+              status: "not_found",
+              success: false,
+              error: `未找到编码为 ${code} 的中间件插件`
+            });
+            continue;
+          }
+
+          registry.loadedPlugins.set(code, {
+            code,
+            name: target.name,
+            version: target.version,
+            loadedAt: new Date().toISOString(),
+            loadResult: { batch: true }
+          });
+
+          results.push({
+            code,
+            name: target.name,
+            version: target.version,
+            status: "loaded",
+            success: true,
+            loadedAt: registry.loadedPlugins.get(code).loadedAt
+          });
+        }
+
+        return {
+          success: true,
+          total: pluginCodes.length,
+          loaded: results.filter(r => r.status === "loaded").length,
+          alreadyLoaded: results.filter(r => r.status === "already_loaded").length,
+          failed: results.filter(r => !r.success).length,
+          results
+        };
+      },
+      {
+        name: "batch_load_middleware_plugins",
+        description: "批量加载多个中间件插件。传入插件编码数组，一次性加载所有指定的中间件插件。",
+        schema: z.object({
+          pluginCodes: z.array(z.string().min(1)).min(1)
+            .describe("要批量加载的中间件插件编码数组，例如 ['weather-query', 'pg-query-tool']")
+        })
+      }
+    );
+
+    return {
+      name: MIDDLEWARE_PROVIDER,
+      tools: [
+        listMiddlewarePlugins,
+        loadMiddlewarePlugin,
+        unloadMiddlewarePlugin,
+        getMiddlewarePluginStatus,
+        refreshPluginCache,
+        batchLoadMiddlewarePlugins
+      ]
+    };
+  }
+}
+
+Injectable()(PluginMiddleware);
+AgentMiddlewareStrategy(MIDDLEWARE_PROVIDER)(PluginMiddleware);
+
+class PluginModule {}
+
+const plugin = {
+  meta: {
+    name: "@timmy_hu/plugin-middleware",
+    version: "1.0.0",
+    level: "organization",
+    category: "middleware",
+    displayName: "插件中间件",
+    description: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。",
+    keywords: ["middleware", "plugin", "discovery", "dynamic-loading", "agent", "orchestration"],
+    author: "fpi"
+  },
+  register(ctx) {
+    if (ctx && ctx.logger) {
+      ctx.logger.log("register plugin-middleware middleware plugin");
+    }
+    return {
+      module: PluginModule,
+      global: true,
+      providers: [PluginMiddleware],
+      controllers: [],
+      exports: [PluginMiddleware]
+    };
+  }
+};
+
+module.exports = plugin;
+module.exports.default = plugin;

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@timmy_hu/plugin-middleware",
+  "version": "1.0.0",
+  "description": "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询",
+  "main": "index.js",
+  "scripts": {
+    "build": "echo 'No build step required for CJS plugin'",
+    "test": "node -e \"require('./index.js')\""
+  },
+  "dependencies": {
+    "@langchain/core": "^0.3.0",
+    "@nestjs/common": "^11.0.0",
+    "reflect-metadata": "^0.2.0",
+    "rxjs": "^7.8.2",
+    "zod": "^3.23.0"
+  },
+  "peerDependencies": {
+    "@xpert-ai/plugin-sdk": "^3.14.0"
+  },
+  "keywords": [
+    "middleware",
+    "plugin",
+    "discovery",
+    "dynamic-loading",
+    "agent"
+  ],
+  "author": "fpi",
+  "license": "MIT"
+}