@timmy_hu/plugin-middleware 1.0.0 → 1.0.1

package/index.js

@@ -15,134 +15,191 @@ 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 and provides dynamic on-demand loading, unloading, and status query tools for agent orchestration. Authenticates via /api/auth/login.",
+        zh_Hans: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询。通过 /api/auth/login 登录获取 token 后调用平台 API。"
       },
       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: "自动发现"
-            },
+            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 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
+    // In-memory registry
     const registry = {
       plugins: new Map(),
       loadedPlugins: new Map(),
       lastRefresh: null,
-      cacheTtl: cacheTtlSeconds * 1000
+      cacheTtl: cacheTtlSeconds * 1000,
+      token: null,
+      tokenExpiry: null
     };
 
-    // Helper: fetch middleware plugins from platform API
-    async function fetchMiddlewarePlugins() {
+    // ---- Login: call /api/auth/login to get token ----
+    async function loginAndGetToken() {
       const now = Date.now();
-      if (registry.lastRefresh && (now - registry.lastRefresh) < registry.cacheTtl) {
-        return Array.from(registry.plugins.values());
+      // Reuse token if still valid (within 50 minutes, assuming 1h expiry)
+      if (registry.token && registry.tokenExpiry && now < registry.tokenExpiry) {
+        return registry.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
-        });
+      if (!email || !password) {
+        throw new Error("缺少登录凭据：请在插件配置中填写 email 和 password");
+      }
 
-        if (!resp.ok) {
-          throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
-        }
+      const fetch = (await import("node-fetch")).default;
+      const loginUrl = `${platformUrl}/api/auth/login`;
+      const resp = await fetch(loginUrl, {
+        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 字段，响应: ${JSON.stringify(data)}`);
+      }
 
-        const data = await resp.json();
-        const pluginList = Array.isArray(data) ? data : (data.data || data.items || data.plugins || []);
+      registry.token = token;
+      // Assume token expires in 50 minutes (conservative)
+      registry.tokenExpiry = now + 50 * 60 * 1000;
+      return token;
+    }
 
-        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)
-            });
+    // ---- Helper: build auth headers ----
+    function authHeaders(token) {
+      const headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      };
+      if (organizationId) {
+        headers["organization-id"] = organizationId;
+      }
+      return headers;
+    }
+
+    // ---- Fetch middleware plugins from platform ----
+    async function fetchMiddlewarePlugins() {
+      const now = Date.now();
+      if (registry.lastRefresh && (now - registry.lastRefresh) < registry.cacheTtl) {
+        return Array.from(registry.plugins.values());
+      }
+
+      const token = await loginAndGetToken();
+      const fetch = (await import("node-fetch")).default;
+      const url = `${platformUrl}/api/plugin?category=middleware`;
+      const resp = await fetch(url, {
+        method: "GET",
+        headers: authHeaders(token),
+        timeout: 10000
+      });
+
+      if (!resp.ok) {
+        // If 401, try re-login once
+        if (resp.status === 401) {
+          registry.token = null;
+          registry.tokenExpiry = null;
+          const newToken = await loginAndGetToken();
+          const retryResp = await fetch(url, {
+            method: "GET",
+            headers: authHeaders(newToken),
+            timeout: 10000
+          });
+          if (!retryResp.ok) {
+            throw new Error(`Platform API returned ${retryResp.status}: ${retryResp.statusText}`);
           }
+          const retryData = await retryResp.json();
+          return parsePluginList(retryData);
         }
+        throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
+      }
 
-        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());
+      const data = await resp.json();
+      return parsePluginList(data);
+    }
+
+    function parsePluginList(data) {
+      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)
+          });
         }
-        throw new Error(`Failed to discover middleware plugins: ${err.message}`);
       }
+      registry.lastRefresh = Date.now();
+      return Array.from(registry.plugins.values());
     }
 
-    // Tool 1: List all discovered middleware plugins
+    // ======== Tool 1: list_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,
@@ -158,11 +215,7 @@ class PluginMiddleware {
             }))
           };
         } catch (err) {
-          return {
-            success: false,
-            error: err.message,
-            plugins: []
-          };
+          return { success: false, error: err.message, plugins: [] };
         }
       },
       {
@@ -175,27 +228,20 @@ class PluginMiddleware {
       }
     );
 
-    // Tool 2: Load a specific middleware plugin by code
+    // ======== Tool 2: load_middleware_plugin ========
     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"
-            }
+            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,
@@ -205,70 +251,35 @@ class PluginMiddleware {
         }
 
         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/load`, {
             method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...(organizationId ? { "organization-id": organizationId } : {})
-            },
-            body: JSON.stringify({
-              pluginName: target.name || pluginCode,
-              version: target.version,
-              source: "npm"
-            }),
+            headers: authHeaders(token),
+            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
+            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"
-            }
+            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 }
+            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: true, message: `插件 ${pluginCode} 已标记为加载（离线模式）`,
+            plugin: { code: pluginCode, name: target.name, version: target.version, loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt, status: "loaded_offline", warning: err.message }
           };
         }
       },
@@ -281,11 +292,10 @@ class PluginMiddleware {
       }
     );
 
-    // Tool 3: Unload a specific middleware plugin
+    // ======== Tool 3: unload_middleware_plugin ========
     const unloadMiddlewarePlugin = tool(
       async (input) => {
         const pluginCode = input.pluginCode;
-
         if (!registry.loadedPlugins.has(pluginCode)) {
           return {
             success: false,
@@ -293,20 +303,15 @@ class PluginMiddleware {
             loadedPlugins: Array.from(registry.loadedPlugins.keys())
           };
         }
-
         try {
+          const token = await loginAndGetToken();
           const fetch = (await import("node-fetch")).default;
-          const unloadUrl = `${platformUrl}/api/plugin/unload`;
-          const resp = await fetch(unloadUrl, {
+          const resp = await fetch(`${platformUrl}/api/plugin/unload`, {
             method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...(organizationId ? { "organization-id": organizationId } : {})
-            },
+            headers: authHeaders(token),
             body: JSON.stringify({ pluginCode }),
             timeout: 15000
           });
-
           if (!resp.ok) {
             const errText = await resp.text();
             throw new Error(`Unload API returned ${resp.status}: ${errText}`);
@@ -314,19 +319,11 @@ class PluginMiddleware {
         } 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"
-          }
+          success: true, message: `插件 ${pluginCode} 已卸载`,
+          plugin: { code: pluginCode, name: removed.name, unloadedAt: new Date().toISOString(), status: "unloaded" }
         };
       },
       {
@@ -338,31 +335,22 @@ class PluginMiddleware {
       }
     );
 
-    // Tool 4: Query detailed status of a specific middleware plugin
+    // ======== Tool 4: get_middleware_plugin_status ========
     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} 的中间件插件`
-          };
+          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,
+            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 || []) : [],
@@ -379,10 +367,12 @@ class PluginMiddleware {
       }
     );
 
-    // Tool 5: Refresh the plugin discovery cache
+    // ======== Tool 5: refresh_plugin_cache ========
     const refreshPluginCache = tool(
       async (input) => {
         registry.lastRefresh = null;
+        registry.token = null;
+        registry.tokenExpiry = null;
         try {
           const plugins = await fetchMiddlewarePlugins();
           return {
@@ -392,69 +382,58 @@ class PluginMiddleware {
             refreshedAt: new Date().toISOString()
           };
         } catch (err) {
-          return {
-            success: false,
-            error: `刷新缓存失败: ${err.message}`
-          };
+          return { success: false, error: `刷新缓存失败: ${err.message}` };
         }
       },
       {
         name: "refresh_plugin_cache",
-        description: "刷新中间件插件发现缓存，强制从平台重新获取所有中间件类型插件列表。",
+        description: "刷新中间件插件发现缓存，强制重新登录并获取所有中间件类型插件列表。",
         schema: z.object({})
       }
     );
 
-    // Tool 6: Batch load multiple middleware plugins
+    // ======== Tool 6: batch_load_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
-            });
+            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} 的中间件插件`
-            });
+            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
-          });
+          try {
+            const token = await loginAndGetToken();
+            const fetch = (await import("node-fetch")).default;
+            const resp = await fetch(`${platformUrl}/api/plugin/load`, {
+              method: "POST",
+              headers: authHeaders(token),
+              body: JSON.stringify({ pluginName: target.name || code, version: target.version, source: "npm" }),
+              timeout: 30000
+            });
+            if (!resp.ok) throw new Error(`Load API returned ${resp.status}`);
+            const result = await resp.json();
+            registry.loadedPlugins.set(code, {
+              code, name: target.name, version: target.version,
+              loadedAt: new Date().toISOString(), loadResult: result
+            });
+            results.push({ code, name: target.name, version: target.version, status: "loaded", success: true, loadedAt: registry.loadedPlugins.get(code).loadedAt });
+          } catch (err) {
+            registry.loadedPlugins.set(code, {
+              code, name: target.name, version: target.version,
+              loadedAt: new Date().toISOString(), loadResult: { offline: true, error: err.message }
+            });
+            results.push({ code, name: target.name, version: target.version, status: "loaded_offline", success: true, warning: err.message });
+          }
         }
-
         return {
-          success: true,
-          total: pluginCodes.length,
+          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,
@@ -471,6 +450,36 @@ class PluginMiddleware {
       }
     );
 
+    // ======== Tool 7: login_status ========
+    const checkLoginStatus = tool(
+      async (input) => {
+        try {
+          const token = await loginAndGetToken();
+          return {
+            success: true,
+            loggedIn: true,
+            email: email,
+            platformUrl: platformUrl,
+            tokenExpiry: registry.tokenExpiry ? new Date(registry.tokenExpiry).toISOString() : null,
+            message: "登录状态正常，token 有效"
+          };
+        } catch (err) {
+          return {
+            success: false,
+            loggedIn: false,
+            email: email,
+            platformUrl: platformUrl,
+            error: err.message
+          };
+        }
+      },
+      {
+        name: "check_login_status",
+        description: "检查当前平台登录状态，验证 email/password 是否有效、token 是否过期。",
+        schema: z.object({})
+      }
+    );
+
     return {
       name: MIDDLEWARE_PROVIDER,
       tools: [
@@ -479,7 +488,8 @@ class PluginMiddleware {
         unloadMiddlewarePlugin,
         getMiddlewarePluginStatus,
         refreshPluginCache,
-        batchLoadMiddlewarePlugins
+        batchLoadMiddlewarePlugins,
+        checkLoginStatus
       ]
     };
   }
@@ -493,11 +503,11 @@ class PluginModule {}
 const plugin = {
   meta: {
     name: "@timmy_hu/plugin-middleware",
-    version: "1.0.0",
+    version: "1.0.1",
     level: "organization",
     category: "middleware",
     displayName: "插件中间件",
-    description: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。",
+    description: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询。通过 /api/auth/login 登录获取 token 后调用平台 API。",
     keywords: ["middleware", "plugin", "discovery", "dynamic-loading", "agent", "orchestration"],
     author: "fpi"
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timmy_hu/plugin-middleware",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询",
   "main": "index.js",
   "scripts": {