@timmy_hu/plugin-middleware 1.0.0 → 1.0.2

package/index.js

@@ -15,459 +15,458 @@ class PluginMiddleware {
         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: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。"
+        en_US: "Discovers all middleware-type plugins installed on the XpertAI platform, shows their load status, and can install new middleware plugins from npm. Authenticates via /api/auth/login.",
+        zh_Hans: "自动发现 XpertAI 平台上所有已安装的中间件类型插件，展示加载状态，并支持从 npm 安装新的中间件插件。通过 /api/auth/login 登录获取 token。"
       },
       configSchema: {
         type: "object",
         properties: {
           platformUrl: {
             type: "string",
-            title: {
-              en_US: "Platform URL",
-              zh_Hans: "平台地址"
-            },
-            description: "XpertAI platform base URL for plugin discovery API",
+            title: { en_US: "Platform URL", zh_Hans: "平台地址" },
+            description: "XpertAI platform base URL",
             default: "http://10.161.48.53:3300"
           },
+          email: {
+            type: "string",
+            title: { en_US: "Email", zh_Hans: "登录邮箱" },
+            description: "Email address for platform login via /api/auth/login"
+          },
+          password: {
+            type: "string",
+            title: { en_US: "Password", zh_Hans: "登录密码" },
+            description: "Password for platform login via /api/auth/login"
+          },
           organizationId: {
             type: "string",
-            title: {
-              en_US: "Organization ID",
-              zh_Hans: "组织 ID"
-            },
+            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: "缓存有效期（秒）"
-            },
+            title: { en_US: "Cache TTL (seconds)", zh_Hans: "缓存有效期（秒）" },
             description: "How long to cache the discovered plugin list before refreshing",
             default: 300
           }
         },
-        required: ["platformUrl"]
+        required: ["platformUrl", "email", "password"]
       }
     };
   }
 
   createMiddleware(options = {}, context = {}) {
-    const platformUrl = options.platformUrl || "http://10.161.48.53:3300";
+    const platformUrl = (options.platformUrl || "http://10.161.48.53:3300").replace(/\/+$/, "");
+    const email = options.email || "";
+    const password = options.password || "";
     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(),
+    // In-memory state
+    const state = {
+      allPlugins: [],          // 所有插件列表
+      middlewarePlugins: [],   // 中间件类型插件列表
       lastRefresh: null,
-      cacheTtl: cacheTtlSeconds * 1000
+      cacheTtl: cacheTtlSeconds * 1000,
+      token: null,
+      tokenExpiry: null
     };
 
-    // Helper: fetch middleware plugins from platform API
-    async function fetchMiddlewarePlugins() {
+    // ======== 登录：调用 /api/auth/login 获取 token ========
+    async function loginAndGetToken() {
       const now = Date.now();
-      if (registry.lastRefresh && (now - registry.lastRefresh) < registry.cacheTtl) {
-        return Array.from(registry.plugins.values());
+      if (state.token && state.tokenExpiry && now < state.tokenExpiry) {
+        return state.token;
+      }
+      if (!email || !password) {
+        throw new Error("缺少登录凭据：请在插件配置中填写 email 和 password");
+      }
+      const fetch = (await import("node-fetch")).default;
+      const resp = await fetch(`${platformUrl}/api/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+        timeout: 15000
+      });
+      if (!resp.ok) {
+        const errText = await resp.text();
+        throw new Error(`登录失败 (${resp.status}): ${errText}`);
+      }
+      const data = await resp.json();
+      const token = data.access_token || data.token || (data.data && data.data.access_token);
+      if (!token) {
+        throw new Error(`登录响应中未找到 token 字段`);
       }
+      state.token = token;
+      state.tokenExpiry = now + 50 * 60 * 1000;
+      return token;
+    }
 
-      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
-        });
+    function authHeaders(token) {
+      const h = { "Content-Type": "application/json", "Authorization": `Bearer ${token}` };
+      if (organizationId) h["organization-id"] = organizationId;
+      return h;
+    }
 
-        if (!resp.ok) {
-          throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
+    // ======== 获取所有已安装插件（GET /api/plugin） ========
+    async function fetchAllPlugins() {
+      const now = Date.now();
+      if (state.lastRefresh && (now - state.lastRefresh) < state.cacheTtl && state.allPlugins.length > 0) {
+        return state.allPlugins;
+      }
+      const token = await loginAndGetToken();
+      const fetch = (await import("node-fetch")).default;
+      const resp = await fetch(`${platformUrl}/api/plugin`, {
+        method: "GET",
+        headers: authHeaders(token),
+        timeout: 15000
+      });
+      if (!resp.ok) {
+        if (resp.status === 401) {
+          state.token = null; state.tokenExpiry = null;
+          const newToken = await loginAndGetToken();
+          const retry = await fetch(`${platformUrl}/api/plugin`, { method: "GET", headers: authHeaders(newToken), timeout: 15000 });
+          if (!retry.ok) throw new Error(`Platform API returned ${retry.status}`);
+          const retryData = await retry.json();
+          return processPluginList(retryData);
         }
+        throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
+      }
+      const data = await resp.json();
+      return processPluginList(data);
+    }
 
-        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)
-            });
-          }
-        }
+    function processPluginList(data) {
+      const list = Array.isArray(data) ? data : (data.data || data.items || data.plugins || []);
+      state.allPlugins = list;
+      state.middlewarePlugins = list.filter(p => {
+        const meta = p.meta || {};
+        return meta.category === "middleware";
+      });
+      state.lastRefresh = Date.now();
+      return state.allPlugins;
+    }
 
-        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}`);
-      }
+    // ======== 格式化中间件插件信息 ========
+    function formatMiddlewarePlugin(p) {
+      const meta = p.meta || {};
+      return {
+        name: p.name || meta.name,
+        packageName: p.packageName || "",
+        displayName: meta.displayName || p.name || meta.name,
+        version: meta.version || p.currentVersion || "unknown",
+        description: meta.description || "",
+        category: meta.category || "unknown",
+        author: meta.author || "",
+        keywords: meta.keywords || [],
+        source: p.source || "",
+        loadStatus: p.loadStatus || "unknown",
+        loadError: p.loadError || null,
+        configurationStatus: p.configurationStatus || null,
+        configurationError: p.configurationError || null,
+        canConfigure: p.canConfigure || false,
+        canUninstall: p.canUninstall || false,
+        canUpdate: p.canUpdate || false,
+        hasUpdate: p.hasUpdate || false,
+        effectiveInCurrentScope: p.effectiveInCurrentScope !== false,
+        componentSummary: p.componentSummary || { total: 0, skills: 0, mcpServers: 0, apps: 0, hooks: 0 }
+      };
     }
 
-    // Tool 1: List all discovered middleware plugins
+    // ======== Tool 1: list_middleware_plugins ========
     const listMiddlewarePlugins = tool(
       async (input) => {
         try {
-          const plugins = await fetchMiddlewarePlugins();
+          await fetchAllPlugins();
           const filter = input.filter || "all";
+          let filtered = state.middlewarePlugins;
 
-          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));
+            filtered = filtered.filter(p => p.loadStatus === "loaded");
+          } else if (filter === "error") {
+            filtered = filtered.filter(p => p.loadStatus === "error" || p.loadError);
+          } else if (filter === "updatable") {
+            filtered = filtered.filter(p => p.hasUpdate === true);
           }
 
           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
-            }))
+            totalAllPlugins: state.allPlugins.length,
+            totalMiddleware: state.middlewarePlugins.length,
+            filter,
+            plugins: filtered.map(formatMiddlewarePlugin)
           };
         } catch (err) {
-          return {
-            success: false,
-            error: err.message,
-            plugins: []
-          };
+          return { success: false, error: err.message, plugins: [] };
         }
       },
       {
         name: "list_middleware_plugins",
-        description: "列出所有已发现的中间件类型插件，可按加载状态过滤。返回插件编码、名称、版本、描述和当前状态。",
+        description: "列出平台上所有已安装的中间件类型插件，可按状态过滤。返回插件名称、版本、描述、加载状态等详细信息。",
         schema: z.object({
-          filter: z.enum(["all", "loaded", "available"]).optional().default("all")
-            .describe("过滤条件：all=全部, loaded=已加载, available=可用未加载")
+          filter: z.enum(["all", "loaded", "error", "updatable"]).optional().default("all")
+            .describe("过滤条件：all=全部, loaded=已加载, error=加载出错, updatable=有可用更新")
         })
       }
     );
 
-    // Tool 2: Load a specific middleware plugin by code
-    const loadMiddlewarePlugin = tool(
+    // ======== Tool 2: get_middleware_plugin_detail ========
+    const getMiddlewarePluginDetail = tool(
       async (input) => {
-        const pluginCode = input.pluginCode;
+        try {
+          await fetchAllPlugins();
+          const keyword = input.pluginNameOrPackage;
+          const found = state.middlewarePlugins.find(p => {
+            const meta = p.meta || {};
+            return p.name === keyword
+              || meta.name === keyword
+              || p.packageName === keyword
+              || meta.displayName === keyword;
+          });
 
-        if (registry.loadedPlugins.has(pluginCode)) {
-          return {
-            success: true,
-            message: `插件 ${pluginCode} 已经处于加载状态`,
-            plugin: {
-              code: pluginCode,
-              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
-              status: "already_loaded"
-            }
-          };
-        }
+          if (!found) {
+            return {
+              success: false,
+              error: `未找到名为 "${keyword}" 的中间件插件`,
+              availableMiddleware: state.middlewarePlugins.map(p => ({
+                name: p.name, packageName: p.packageName, displayName: (p.meta || {}).displayName
+              }))
+            };
+          }
 
-        // Discover if not yet known
-        const plugins = await fetchMiddlewarePlugins();
-        const target = plugins.find(p => p.code === pluginCode);
+          const detail = formatMiddlewarePlugin(found);
 
-        if (!target) {
-          return {
-            success: false,
-            error: `未找到编码为 ${pluginCode} 的中间件插件`,
-            availablePlugins: plugins.map(p => p.code)
-          };
+          // 尝试获取组件信息
+          try {
+            const token = await loginAndGetToken();
+            const fetch = (await import("node-fetch")).default;
+            const compResp = await fetch(`${platformUrl}/api/plugin/${encodeURIComponent(found.name)}/components`, {
+              method: "GET", headers: authHeaders(token), timeout: 10000
+            });
+            if (compResp.ok) {
+              const compData = await compResp.json();
+              detail.components = compData.items || compData;
+            }
+          } catch (e) {
+            detail.components = [];
+          }
+
+          return { success: true, plugin: detail };
+        } catch (err) {
+          return { success: false, error: err.message };
         }
+      },
+      {
+        name: "get_middleware_plugin_detail",
+        description: "查询指定中间件插件的详细信息，包括加载状态、配置状态、组件列表、版本信息等。",
+        schema: z.object({
+          pluginNameOrPackage: z.string().min(1)
+            .describe("插件名称、packageName 或 displayName，例如 'echarts-generator' 或 '@timmy_hu/bulk-email-sender'")
+        })
+      }
+    );
+
+    // ======== Tool 3: install_middleware_plugin ========
+    const installMiddlewarePlugin = tool(
+      async (input) => {
+        const packageName = input.packageName;
+        const version = input.version || "latest";
 
         try {
-          // Attempt to load via platform API
+          const token = await loginAndGetToken();
           const fetch = (await import("node-fetch")).default;
-          const loadUrl = `${platformUrl}/api/plugin/load`;
-          const resp = await fetch(loadUrl, {
+          const resp = await fetch(`${platformUrl}/api/plugin`, {
             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
+            headers: authHeaders(token),
+            body: JSON.stringify({ pluginName: packageName, version, source: "npm" }),
+            timeout: 60000
           });
 
           if (!resp.ok) {
             const errText = await resp.text();
-            throw new Error(`Load API returned ${resp.status}: ${errText}`);
+            throw new Error(`安装失败 (${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
-          });
+          // 刷新缓存
+          state.lastRefresh = null;
 
           return {
             success: true,
-            message: `插件 ${pluginCode} 加载成功`,
-            plugin: {
-              code: pluginCode,
-              name: target.name,
-              version: target.version,
-              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
-              status: "loaded"
+            message: `插件 ${packageName} 安装成功`,
+            installed: {
+              name: result.name || packageName,
+              packageName: result.packageName || packageName,
+              version: result.currentVersion || version,
+              organizationId: result.organizationId || organizationId
             }
           };
         } 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
-            }
+            success: false,
+            error: err.message,
+            packageName,
+            version
           };
         }
       },
       {
-        name: "load_middleware_plugin",
-        description: "按插件编码动态加载指定的中间件插件。加载后该插件的工具和能力将对智能体可用。",
+        name: "install_middleware_plugin",
+        description: "从 npm 安装一个新的中间件插件到 XpertAI 平台。安装后插件将自动加载并可供智能体使用。",
         schema: z.object({
-          pluginCode: z.string().min(1).describe("要加载的中间件插件编码，例如 'weather-query' 或 'pg-query-tool'")
+          packageName: z.string().min(1).describe("npm 包名，例如 '@timmy_hu/bulk-email-sender'"),
+          version: z.string().optional().default("latest").describe("版本号，默认为 latest")
         })
       }
     );
 
-    // Tool 3: Unload a specific middleware plugin
-    const unloadMiddlewarePlugin = tool(
+    // ======== Tool 4: refresh_plugin_list ========
+    const refreshPluginList = tool(
       async (input) => {
-        const pluginCode = input.pluginCode;
-
-        if (!registry.loadedPlugins.has(pluginCode)) {
+        state.lastRefresh = null;
+        state.token = null;
+        state.tokenExpiry = null;
+        try {
+          await fetchAllPlugins();
           return {
-            success: false,
-            error: `插件 ${pluginCode} 当前未加载，无需卸载`,
-            loadedPlugins: Array.from(registry.loadedPlugins.keys())
+            success: true,
+            message: `插件列表已刷新，共发现 ${state.allPlugins.length} 个插件，其中 ${state.middlewarePlugins.length} 个中间件类型`,
+            totalPlugins: state.allPlugins.length,
+            totalMiddleware: state.middlewarePlugins.length,
+            refreshedAt: new Date().toISOString()
           };
-        }
-
-        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
+          return { success: false, error: `刷新失败: ${err.message}` };
         }
-
-        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("要卸载的中间件插件编码")
-        })
+        name: "refresh_plugin_list",
+        description: "刷新插件列表缓存，强制重新登录并从平台获取所有已安装插件的最新状态。",
+        schema: z.object({})
       }
     );
 
-    // Tool 4: Query detailed status of a specific middleware plugin
-    const getMiddlewarePluginStatus = tool(
+    // ======== Tool 5: check_login_status ========
+    const checkLoginStatus = tool(
       async (input) => {
-        const pluginCode = input.pluginCode;
-        const plugins = await fetchMiddlewarePlugins();
-        const target = plugins.find(p => p.code === pluginCode);
-
-        if (!target) {
+        try {
+          const token = await loginAndGetToken();
+          return {
+            success: true,
+            loggedIn: true,
+            email,
+            platformUrl,
+            organizationId: organizationId || "(未设置)",
+            tokenExpiry: state.tokenExpiry ? new Date(state.tokenExpiry).toISOString() : null,
+            cachedPlugins: state.allPlugins.length,
+            cachedMiddleware: state.middlewarePlugins.length,
+            message: "登录状态正常，token 有效"
+          };
+        } catch (err) {
           return {
             success: false,
-            error: `未找到编码为 ${pluginCode} 的中间件插件`
+            loggedIn: false,
+            email,
+            platformUrl,
+            error: err.message
           };
         }
-
-        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("要查询的中间件插件编码")
-        })
+        name: "check_login_status",
+        description: "检查当前平台登录状态，验证 email/password 是否有效、token 是否过期，以及缓存中有多少插件。",
+        schema: z.object({})
       }
     );
 
-    // Tool 5: Refresh the plugin discovery cache
-    const refreshPluginCache = tool(
+    // ======== Tool 6: search_middleware_plugins ========
+    const searchMiddlewarePlugins = tool(
       async (input) => {
-        registry.lastRefresh = null;
         try {
-          const plugins = await fetchMiddlewarePlugins();
+          await fetchAllPlugins();
+          const keyword = (input.keyword || "").toLowerCase();
+          const results = state.middlewarePlugins.filter(p => {
+            const meta = p.meta || {};
+            const searchFields = [
+              p.name, p.packageName, meta.name, meta.displayName,
+              meta.description, (meta.keywords || []).join(" ")
+            ].map(s => (s || "").toLowerCase());
+            return searchFields.some(f => f.includes(keyword));
+          });
+
           return {
             success: true,
-            message: `缓存已刷新，发现 ${plugins.length} 个中间件插件`,
-            total: plugins.length,
-            refreshedAt: new Date().toISOString()
+            keyword: input.keyword,
+            total: results.length,
+            plugins: results.map(formatMiddlewarePlugin)
           };
         } catch (err) {
-          return {
-            success: false,
-            error: `刷新缓存失败: ${err.message}`
-          };
+          return { success: false, error: err.message, plugins: [] };
         }
       },
       {
-        name: "refresh_plugin_cache",
-        description: "刷新中间件插件发现缓存，强制从平台重新获取所有中间件类型插件列表。",
-        schema: z.object({})
+        name: "search_middleware_plugins",
+        description: "按关键词搜索中间件类型插件。搜索范围包括插件名称、包名、描述和关键词。",
+        schema: z.object({
+          keyword: z.string().min(1).describe("搜索关键词，例如 'echarts'、'email'、'retry'")
+        })
       }
     );
 
-    // Tool 6: Batch load multiple middleware plugins
-    const batchLoadMiddlewarePlugins = tool(
+    // ======== Tool 7: get_plugin_statistics ========
+    const getPluginStatistics = tool(
       async (input) => {
-        const pluginCodes = input.pluginCodes;
-        const results = [];
-
-        const plugins = await fetchMiddlewarePlugins();
+        try {
+          await fetchAllPlugins();
 
-        for (const code of pluginCodes) {
-          if (registry.loadedPlugins.has(code)) {
-            results.push({
-              code,
-              status: "already_loaded",
-              success: true
-            });
-            continue;
+          // 按 category 统计
+          const categoryStats = {};
+          for (const p of state.allPlugins) {
+            const cat = (p.meta || {}).category || "unknown";
+            categoryStats[cat] = (categoryStats[cat] || 0) + 1;
           }
 
-          const target = plugins.find(p => p.code === code);
-          if (!target) {
-            results.push({
-              code,
-              status: "not_found",
-              success: false,
-              error: `未找到编码为 ${code} 的中间件插件`
-            });
-            continue;
+          // 按 loadStatus 统计中间件
+          const loadStatusStats = {};
+          for (const p of state.middlewarePlugins) {
+            const ls = p.loadStatus || "unknown";
+            loadStatusStats[ls] = (loadStatusStats[ls] || 0) + 1;
           }
 
-          registry.loadedPlugins.set(code, {
-            code,
-            name: target.name,
-            version: target.version,
-            loadedAt: new Date().toISOString(),
-            loadResult: { batch: true }
-          });
+          // 有更新的插件
+          const updatable = state.middlewarePlugins.filter(p => p.hasUpdate === true);
 
-          results.push({
-            code,
-            name: target.name,
-            version: target.version,
-            status: "loaded",
+          // 有配置错误的插件
+          const configErrors = state.middlewarePlugins.filter(p => p.configurationError);
+
+          // 有加载错误的插件
+          const loadErrors = state.middlewarePlugins.filter(p => p.loadError);
+
+          return {
             success: true,
-            loadedAt: registry.loadedPlugins.get(code).loadedAt
-          });
+            statistics: {
+              totalPlugins: state.allPlugins.length,
+              totalMiddleware: state.middlewarePlugins.length,
+              byCategory: categoryStats,
+              middlewareByLoadStatus: loadStatusStats,
+              updatableCount: updatable.length,
+              updatablePlugins: updatable.map(p => ({ name: p.name, packageName: p.packageName, version: (p.meta || {}).version })),
+              configErrorCount: configErrors.length,
+              configErrorPlugins: configErrors.map(p => ({ name: p.name, error: p.configurationError })),
+              loadErrorCount: loadErrors.length,
+              loadErrorPlugins: loadErrors.map(p => ({ name: p.name, error: p.loadError }))
+            },
+            generatedAt: new Date().toISOString()
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
         }
-
-        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']")
-        })
+        name: "get_plugin_statistics",
+        description: "获取平台上所有插件的统计信息，包括按分类统计、按加载状态统计、有更新的插件、有错误的插件等。",
+        schema: z.object({})
       }
     );
 
@@ -475,11 +474,12 @@ class PluginMiddleware {
       name: MIDDLEWARE_PROVIDER,
       tools: [
         listMiddlewarePlugins,
-        loadMiddlewarePlugin,
-        unloadMiddlewarePlugin,
-        getMiddlewarePluginStatus,
-        refreshPluginCache,
-        batchLoadMiddlewarePlugins
+        getMiddlewarePluginDetail,
+        installMiddlewarePlugin,
+        refreshPluginList,
+        checkLoginStatus,
+        searchMiddlewarePlugins,
+        getPluginStatistics
       ]
     };
   }
@@ -493,12 +493,12 @@ class PluginModule {}
 const plugin = {
   meta: {
     name: "@timmy_hu/plugin-middleware",
-    version: "1.0.0",
+    version: "1.0.2",
     level: "organization",
     category: "middleware",
     displayName: "插件中间件",
-    description: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。",
-    keywords: ["middleware", "plugin", "discovery", "dynamic-loading", "agent", "orchestration"],
+    description: "自动发现 XpertAI 平台上所有已安装的中间件类型插件，展示加载状态，支持从 npm 安装新插件、搜索、统计。通过 /api/auth/login 登录获取 token。",
+    keywords: ["middleware", "plugin", "discovery", "install", "agent", "orchestration"],
     author: "fpi"
   },
   register(ctx) {