foliko 1.1.13 → 1.1.14

package/.agent/plugins/puppeteer-plugin/index.js

@@ -0,0 +1,1422 @@
+const { z } = require('zod');
+const path = require('path');
+const fs = require('fs');
+
+// Session 存储路径
+const SESSION_DIR = path.join(process.cwd(), '.agent', 'data', 'puppeteer-sessions');
+if (!fs.existsSync(SESSION_DIR)) {
+  fs.mkdirSync(SESSION_DIR, { recursive: true });
+}
+
+module.exports = function (Plugin) {
+  return class PuppeteerPlugin extends Plugin {
+    constructor(config = {}) {
+      super();
+      this.name = 'puppeteer';
+      this.version = '1.0.0';
+      this.description = 'Puppeteer 网页自动化操作插件 - 支持浏览器控制、页面操作、元素交互、Session 管理，你没有识别图片的能力';
+      this.priority = 10;
+      this.config = config;
+
+      // 浏览器实例
+      this.browser = null;
+      this.pages = new Map();
+      this.currentPageId = null;
+
+      // Puppeteer 路径
+      this.puppeteerPath = null;
+      // 浏览器可执行文件路径
+      this.executablePath = config.executablePath || null;
+    }
+
+    // 延迟加载 puppeteer（仅在需要时加载）
+    async getPuppeteer() {
+      if (!this.puppeteer) {
+        // 尝试多个可能的路径
+        const possiblePaths = [
+          path.join(__dirname, 'node_modules', 'puppeteer'),
+          path.join(__dirname, '..', '..', 'node_modules', 'puppeteer'),
+          path.join(process.cwd(), 'node_modules', 'puppeteer'),
+          'puppeteer',
+          path.join(__dirname, 'node_modules', 'puppeteer-core'),
+          path.join(__dirname, '..', '..', 'node_modules', 'puppeteer-core'),
+          path.join(process.cwd(), 'node_modules', 'puppeteer-core'),
+          'puppeteer-core'
+        ];
+
+        for (const p of possiblePaths) {
+          try {
+            this.puppeteer = require(p);
+            this.puppeteerPath = p;
+            break;
+          } catch (e) {
+            continue;
+          }
+        }
+
+        if (!this.puppeteer) {
+          throw new Error('Puppeteer 未安装，请先安装 puppeteer 或 puppeteer-core');
+        }
+      }
+      return this.puppeteer;
+    }
+
+    // 生成页面ID
+    generatePageId() {
+      return `page_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+
+    // 获取当前页面
+    getCurrentPage() {
+      if (!this.currentPageId || !this.pages.has(this.currentPageId)) {
+        throw new Error('没有活动的页面，请先打开页面');
+      }
+      return this.pages.get(this.currentPageId);
+    }
+
+    // ============ 浏览器管理 ============
+
+    tools = {
+      // 启动浏览器
+      browser_launch: {
+        description: '启动 Puppeteer 浏览器实例',
+        inputSchema: z.object({
+          headless: z.boolean().optional().describe('是否无头模式，默认 true'),
+          args: z.array(z.string()).optional().describe('浏览器启动参数'),
+          executablePath: z.string().optional().describe('浏览器可执行文件路径（如使用puppeteer-core）'),
+          userDataDir: z.string().optional().describe('用户数据目录（用于保存Session）'),
+          viewport: z.object({
+            width: z.number().optional().describe('视口宽度'),
+            height: z.number().optional().describe('视口高度'),
+          }).optional().describe('视口设置'),
+          userAgent: z.string().optional().describe('自定义 User-Agent'),
+        }),
+        execute: async (args) => {
+          const puppeteer = await this.getPuppeteer();
+
+          // 如果浏览器已启动，先关闭
+          if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+            this.pages.clear();
+          }
+
+          const launchOptions = {
+            headless: args.headless !== false,
+            args: args.args || [
+              '--no-sandbox',
+              '--disable-setuid-sandbox',
+              '--disable-dev-shm-usage',
+              '--disable-accelerated-2d-canvas',
+              '--disable-gpu'
+            ]
+          };
+
+          // 支持自定义浏览器路径或使用 puppeteer-core
+          if (args.executablePath) {
+            launchOptions.executablePath = args.executablePath;
+          } else if (this.executablePath) {
+            launchOptions.executablePath = this.executablePath;
+          }
+
+          if (args.userDataDir) {
+            launchOptions.userDataDir = args.userDataDir;
+          }
+
+          this.browser = await puppeteer.launch(launchOptions);
+
+          // 创建新页面
+          const page = await this.browser.newPage();
+          const pageId = this.generatePageId();
+          this.pages.set(pageId, page);
+          this.currentPageId = pageId;
+
+          // 设置视口
+          if (args.viewport) {
+            await page.setViewport({
+              width: args.viewport.width || 1920,
+              height: args.viewport.height || 1080
+            });
+          } else {
+            await page.setViewport({ width: 1920, height: 1080 });
+          }
+
+          // 设置 User-Agent
+          if (args.userAgent) {
+            await page.setUserAgent(args.userAgent);
+          }
+
+          return {
+            success: true,
+            message: '浏览器已启动',
+            pageId: pageId,
+            headless: launchOptions.headless
+          };
+        }
+      },
+
+      // 关闭浏览器
+      browser_close: {
+        description: '关闭 Puppeteer 浏览器实例',
+        inputSchema: z.object({}),
+        execute: async () => {
+          if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+            this.pages.clear();
+            this.currentPageId = null;
+          }
+          return { success: true, message: '浏览器已关闭' };
+        }
+      },
+
+      // 获取浏览器状态
+      browser_status: {
+        description: '获取当前浏览器状态',
+        inputSchema: z.object({}),
+        execute: async () => {
+          return {
+            success: true,
+            browserOpen: !!this.browser,
+            pages: Array.from(this.pages.keys()),
+            currentPageId: this.currentPageId
+          };
+        }
+      },
+
+      // ============ 页面操作 ============
+
+      // 打开页面
+      page_open: {
+        description: '打开新页面或导航到URL',
+        inputSchema: z.object({
+          url: z.string().describe('目标URL'),
+          pageId: z.string().optional().describe('指定页面ID，默认新建页面'),
+          waitUntil: z.enum(['load', 'domcontentloaded', 'networkidle0', 'networkidle2', 'commit']).optional().describe('等待策略'),
+        }),
+        execute: async (args) => {
+          const puppeteer = await this.getPuppeteer();
+
+          if (!this.browser) {
+            throw new Error('浏览器未启动，请先调用 browser_launch');
+          }
+
+          let page;
+          if (args.pageId && this.pages.has(args.pageId)) {
+            page = this.pages.get(args.pageId);
+          } else {
+            page = await this.browser.newPage();
+            const newPageId = this.generatePageId();
+            this.pages.set(newPageId, page);
+            this.currentPageId = newPageId;
+          }
+
+          await page.goto(args.url, {
+            waitUntil: args.waitUntil || 'networkidle2',
+            timeout: 30000
+          });
+
+          // 获取标题
+          const title = await page.title();
+          const url = page.url();
+
+          return {
+            success: true,
+            message: '页面已打开',
+            pageId: this.currentPageId,
+            title: title,
+            url: url
+          };
+        }
+      },
+
+      // 页面导航
+      page_navigate: {
+        description: '页面导航操作（前进、后退、刷新）',
+        inputSchema: z.object({
+          action: z.enum(['back', 'forward', 'reload']).describe('导航操作'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          switch (args.action) {
+            case 'back':
+              await page.goBack({ timeout: 30000 });
+              break;
+            case 'forward':
+              await page.goForward({ timeout: 30000 });
+              break;
+            case 'reload':
+              await page.reload({ timeout: 30000 });
+              break;
+          }
+
+          return {
+            success: true,
+            action: args.action,
+            url: page.url(),
+            title: await page.title()
+          };
+        }
+      },
+
+      // 截图
+      page_screenshot: {
+        description: '对页面进行截图，截图只能保存，你没有识别图片的能力',
+        inputSchema: z.object({
+          path: z.string().describe('保存路径，默认临时文件'),
+          fullPage: z.boolean().optional().describe('是否截取整页'),
+          selector: z.string().optional().describe('截取指定元素的截图'),
+          type: z.enum(['png', 'jpeg', 'webp']).optional().describe('图片格式'),
+          quality: z.number().optional().describe('图片质量（1-100）'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const screenshotOptions = {
+            type: args.type || 'png',
+            fullPage: args.fullPage || false
+          };
+
+          if (args.quality && args.type !== 'png') {
+            screenshotOptions.quality = args.quality;
+          }
+
+          let screenshot;
+          if (args.selector) {
+            const element = await page.$(args.selector);
+            if (!element) {
+              throw new Error(`未找到元素: ${args.selector}`);
+            }
+            screenshot = await element.screenshot(screenshotOptions);
+          } else {
+            screenshot = await page.screenshot(screenshotOptions);
+          }
+
+          const fs = require('fs');
+          const dir = path.dirname(args.path);
+          if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+          }
+          fs.writeFileSync(args.path, screenshot);
+          return {
+            success: true,
+            path: args.path,
+            message: `截图已保存到 ${args.path}`
+          };
+        }
+      },
+
+      // 获取页面HTML
+      page_html: {
+        description: '获取页面HTML内容（注意：复杂页面会导致token超标，建议使用 page_structure 获取页面结构）',
+        inputSchema: z.object({
+          contentOnly: z.boolean().optional().describe('仅获取body内容'),
+          toMarkdown: z.boolean().optional().default(true).describe('是否将HTML转换为Markdown格式，默认开启'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          let html = args.contentOnly
+            ? await page.evaluate(() => document.body ? document.body.innerHTML : '')
+            : await page.content();
+
+          // 保存到临时文件
+          const tmpDir = require('os').tmpdir();
+          const filename = `puppeteer_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.html`;
+          const filePath = path.join(tmpDir, filename);
+          fs.writeFileSync(filePath, html, 'utf-8');
+
+          let content;
+          let isMarkdown = false;
+
+          // 如果需要转换为 Markdown（默认为 true）
+          if (args.toMarkdown !== false) {
+            content = this._htmlToMarkdown(html);
+            isMarkdown = true;
+          }
+
+          return {
+            success: true,
+            filePath: filePath,
+            markdown: isMarkdown ? content : undefined,
+            content: isMarkdown ? content : `[HTML已保存到文件: ${filePath}]`,
+            length: html.length,
+            url: page.url()
+          };
+        }
+      },
+
+      // HTML 转 Markdown 辅助方法
+      _htmlToMarkdown(html) {
+        if (!html) return '';
+        
+        // 移除脚本和样式标签内容
+        let markdown = html
+          .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+          .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+          .replace(/<!--[\s\S]*?-->/g, '');
+
+        // 标题转换
+        markdown = markdown.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '# $1\n\n');
+        markdown = markdown.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '## $1\n\n');
+        markdown = markdown.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '### $1\n\n');
+        markdown = markdown.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, '#### $1\n\n');
+        markdown = markdown.replace(/<h5[^>]*>([\s\S]*?)<\/h5>/gi, '##### $1\n\n');
+        markdown = markdown.replace(/<h6[^>]*>([\s\S]*?)<\/h6>/gi, '###### $1\n\n');
+
+        // 换行和段落
+        markdown = markdown.replace(/<br\s*\/?>/gi, '\n');
+        markdown = markdown.replace(/<\/p>/gi, '\n\n');
+        markdown = markdown.replace(/<\/div>/gi, '\n');
+        markdown = markdown.replace(/<\/li>/gi, '\n');
+
+        // 列表
+        markdown = markdown.replace(/<ul[^>]*>/gi, '\n');
+        markdown = markdown.replace(/<ol[^>]*>/gi, '\n');
+        markdown = markdown.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '- $1\n');
+
+        // 链接和图片
+        markdown = markdown.replace(/<a[^>]*href=["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
+        markdown = markdown.replace(/<img[^>]*src=["']([^"']*)["'][^>]*alt=["']([^"']*)["'][^>]*\/?>/gi, '![$2]($1)');
+        markdown = markdown.replace(/<img[^>]*alt=["']([^"']*)["'][^>]*src=["']([^"']*)["'][^>]*\/?>/gi, '![$1]($2)');
+        markdown = markdown.replace(/<img[^>]*src=["']([^"']*)["'][^>]*\/?>/gi, '![]($1)');
+
+        // 粗体和斜体
+        markdown = markdown.replace(/<strong[^>]*>([\s\S]*?)<\/strong>/gi, '**$1**');
+        markdown = markdown.replace(/<b[^>]*>([\s\S]*?)<\/b>/gi, '**$1**');
+        markdown = markdown.replace(/<em[^>]*>([\s\S]*?)<\/em>/gi, '*$1*');
+        markdown = markdown.replace(/<i[^>]*>([\s\S]*?)<\/i>/gi, '*$1*');
+
+        // 代码
+        markdown = markdown.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
+        markdown = markdown.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, '```\n$1\n```');
+
+        // 表格 (简单支持)
+        const tableRegex = /<table[^>]*>([\s\S]*?)<\/table>/gi;
+        markdown = markdown.replace(tableRegex, (match, tableContent) => {
+          let mdTable = '';
+          const rows = tableContent.match(/<tr[^>]*>([\s\S]*?)<\/tr>/gi) || [];
+          rows.forEach((row, idx) => {
+            const cells = row.match(/<t[hd][^>]*>([\s\S]*?)<\/t[hd]>/gi) || [];
+            const mdRow = cells.map(cell => {
+              return cell.replace(/<t[hd][^>]*>/, '').replace(/<\/t[hd]>/, '').trim();
+            }).join(' | ');
+            if (idx === 0) {
+              mdTable += mdRow + '\n' + mdRow.split('|').map(() => '---').join('|') + '\n';
+            } else {
+              mdTable += mdRow + '\n';
+            }
+          });
+          return mdTable + '\n';
+        });
+
+        // 移除所有剩余 HTML 标签
+        markdown = markdown.replace(/<[^>]+>/g, '');
+
+        // 清理实体编码
+        markdown = markdown
+          .replace(/&nbsp;/g, ' ')
+          .replace(/&amp;/g, '&')
+          .replace(/&lt;/g, '<')
+          .replace(/&gt;/g, '>')
+          .replace(/&quot;/g, '"')
+          .replace(/&#39;/g, "'")
+          .replace(/&nbsp;/g, ' ')
+          .replace(/&#(\d+);/g, (match, dec) => String.fromCharCode(dec));
+
+        // 清理多余空行
+        markdown = markdown.replace(/\n{3,}/g, '\n\n').trim();
+
+        return markdown;
+      },
+
+      // 获取页面结构（优化版 - 返回精简的结构化数据，避免token超标）
+      page_structure: {
+        description: '获取页面关键结构信息（推荐使用），返回可交互元素的精简结构，避免获取完整HTML导致的token超标问题',
+        inputSchema: z.object({
+          maxElements: z.number().optional().describe('最大返回元素数量，默认50'),
+          includeHidden: z.boolean().optional().describe('是否包含隐藏元素，默认false'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const maxElements = args.maxElements || 50;
+          const includeHidden = args.includeHidden || false;
+
+          // 在页面中执行结构提取逻辑
+          const structure = await page.evaluate(({ maxEls, hidden }) => {
+            // 可交互元素标签
+            const interactiveTags = ['a', 'button', 'input', 'select', 'textarea', 'label'];
+            const clickableTags = ['a', 'button'];
+
+            // 生成唯一选择器
+            function generateSelector(el) {
+              if (el.id) return `#${CSS.escape(el.id)}`;
+              
+              let selector = el.tagName.toLowerCase();
+              
+              // 优先使用class
+              if (el.className && typeof el.className === 'string' && el.className.trim()) {
+                const classes = el.className.trim().split(/\s+/).slice(0, 2);
+                selector += '.' + classes.map(c => CSS.escape(c)).join('.');
+              }
+              
+              // 添加有意义的属性
+              if (el.name) selector += `[name="${CSS.escape(el.name)}"]`;
+              if (el.type) selector += `[type="${CSS.escape(el.type)}"]`;
+              if (el.placeholder) selector += `[placeholder*="${el.placeholder.substring(0, 20)}"]`;
+              
+              // 添加data属性
+              const dataAttr = [...el.attributes].find(a => a.name.startsWith('data-'));
+              if (dataAttr) selector += `[${dataAttr.name}="${CSS.escape(dataAttr.value.substring(0, 30))}"]`;
+              
+              return selector;
+            }
+
+            // 清理文本，移除多余空白
+            function cleanText(text) {
+              if (!text) return '';
+              return text.replace(/\s+/g, ' ').trim().substring(0, 100);
+            }
+
+            // 收集可交互元素
+            const elements = [];
+            const seen = new Set();
+
+            // 优先收集有明确选择器的元素
+            const allElements = document.querySelectorAll(
+              'a, button, [onclick], [role="button"], input, select, textarea, [tabindex]'
+            );
+
+            for (const el of allElements) {
+              if (elements.length >= maxEls) break;
+              
+              // 跳过隐藏元素
+              if (!hidden) {
+                const style = window.getComputedStyle(el);
+                if (style.display === 'none' || style.visibility === 'hidden') continue;
+              }
+
+              // 生成选择器
+              const selector = generateSelector(el);
+              
+              // 去重
+              if (seen.has(selector)) continue;
+              seen.add(selector);
+
+              // 获取元素信息
+              const rect = el.getBoundingClientRect();
+              const isVisible = rect.width > 0 && rect.height > 0;
+
+              if (!hidden && !isVisible) continue;
+
+              // 获取文本内容
+              let text = '';
+              if (el.tagName === 'INPUT') {
+                text = el.placeholder || el.name || '';
+              } else if (clickableTags.includes(el.tagName)) {
+                text = cleanText(el.textContent) || el.alt || '';
+              } else {
+                text = cleanText(el.textContent);
+              }
+
+              // 获取href/src
+              let href = '';
+              if (el.tagName === 'A') href = el.href || '';
+              else if (el.tagName === 'IMG') href = el.src || '';
+
+              // 获取表单信息
+              let formInfo = {};
+              if (el.tagName === 'INPUT' || el.tagName === 'SELECT' || el.tagName === 'TEXTAREA') {
+                formInfo = {
+                  type: el.type || el.tagName,
+                  name: el.name || '',
+                  value: el.value ? el.value.substring(0, 50) : '',
+                  placeholder: el.placeholder || '',
+                  required: el.required,
+                  disabled: el.disabled
+                };
+              }
+
+              // 获取aria属性
+              const aria = {
+                label: el.getAttribute('aria-label'),
+                role: el.getAttribute('role'),
+                describedby: el.getAttribute('aria-describedby')
+              };
+
+              // 获取data属性
+              const dataAttrs = {};
+              [...el.attributes].forEach(attr => {
+                if (attr.name.startsWith('data-')) {
+                  dataAttrs[attr.name] = attr.value.substring(0, 50);
+                }
+              });
+
+              elements.push({
+                selector: selector,
+                tag: el.tagName.toLowerCase(),
+                id: el.id || null,
+                classes: el.className && typeof el.className === 'string' 
+                  ? el.className.trim().split(/\s+/).filter(c => c) 
+                  : [],
+                text: text,
+                href: href,
+                position: {
+                  x: Math.round(rect.x),
+                  y: Math.round(rect.y),
+                  width: Math.round(rect.width),
+                  height: Math.round(rect.height)
+                },
+                visible: isVisible,
+                ...formInfo,
+                aria,
+                dataAttrs
+              });
+            }
+
+            // 收集表单区域结构
+            const forms = [];
+            document.querySelectorAll('form').forEach(form => {
+              const formData = {
+                selector: generateSelector(form),
+                id: form.id || null,
+                action: form.action || '',
+                method: form.method || 'get',
+                elements: []
+              };
+
+              form.querySelectorAll('input, select, textarea').forEach(input => {
+                formData.elements.push({
+                  selector: generateSelector(input),
+                  tag: input.tagName.toLowerCase(),
+                  type: input.type || 'text',
+                  name: input.name || '',
+                  placeholder: input.placeholder || '',
+                  label: input.labels?.[0]?.textContent?.trim() || 
+                         input.closest('label')?.textContent?.trim() || ''
+                });
+              });
+
+              if (formData.elements.length > 0) {
+                forms.push(formData);
+              }
+            });
+
+            // 获取主要区域结构
+            const regions = [];
+            const mainSelectors = ['header', 'nav', 'main', 'aside', 'footer', '[role="main"]', '[role="navigation"]'];
+            mainSelectors.forEach(sel => {
+              document.querySelectorAll(sel).forEach(el => {
+                if (regions.length >= 10) return;
+                
+                const id = el.id || '';
+                const classes = el.className && typeof el.className === 'string' 
+                  ? el.className.split(/\s+/).slice(0, 2).join(' ') 
+                  : '';
+                
+                regions.push({
+                  selector: generateSelector(el),
+                  tag: el.tagName.toLowerCase(),
+                  role: el.getAttribute('role') || sel.replace(/[\[\]"]/g, ''),
+                  id: id || null,
+                  classes: classes,
+                  heading: el.querySelector('h1, h2, h3')?.textContent?.trim().substring(0, 50) || null,
+                  childCount: el.children.length
+                });
+              });
+            });
+
+            // 获取标题层级
+            const headings = [];
+            document.querySelectorAll('h1, h2, h3, h4, h5, h6').forEach((h, i) => {
+              if (headings.length >= 15) return;
+              headings.push({
+                level: parseInt(h.tagName[1]),
+                text: h.textContent.trim().substring(0, 80),
+                id: h.id || null
+              });
+            });
+
+            return {
+              elements,
+              forms,
+              regions,
+              headings,
+              totalElements: document.querySelectorAll(
+                'a, button, input, select, textarea'
+              ).length
+            };
+          }, { maxEls: maxElements, hidden: includeHidden });
+
+          return {
+            success: true,
+            message: `页面结构已提取，共 ${structure.totalElements} 个可交互元素`,
+            url: page.url(),
+            title: await page.title(),
+            summary: {
+              totalInteractive: structure.totalElements,
+              returnedElements: structure.elements.length,
+              forms: structure.forms.length,
+              regions: structure.regions.length,
+              headings: structure.headings.length
+            },
+            elements: structure.elements,
+            forms: structure.forms,
+            regions: structure.regions,
+            headings: structure.headings,
+            usageTip: '使用 element_find 或 element_click 工具配合返回的 selector 进行元素操作'
+          };
+        }
+      },
+
+      // 关闭页面
+      page_close: {
+        description: '关闭指定页面',
+        inputSchema: z.object({
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const pageId = args.pageId || this.currentPageId;
+          if (!this.pages.has(pageId)) {
+            throw new Error(`页面不存在: ${pageId}`);
+          }
+
+          const page = this.pages.get(pageId);
+          await page.close();
+          this.pages.delete(pageId);
+
+          // 如果关闭的是当前页面，切换到其他页面
+          if (this.currentPageId === pageId) {
+            this.currentPageId = this.pages.keys().next().value || null;
+          }
+
+          return {
+            success: true,
+            message: '页面已关闭',
+            remainingPages: this.pages.size
+          };
+        }
+      },
+
+      // ============ 元素操作 ============
+
+      // 查找元素
+      element_find: {
+        description: '查找页面元素',
+        inputSchema: z.object({
+          selector: z.string().describe('CSS选择器或XPath（以//开头）'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const selector = args.selector;
+          let element;
+          let isXPath = selector.startsWith('//') || selector.startsWith('/');
+
+          if (isXPath) {
+            const elements = await page.$x(selector);
+            element = elements[0] || null;
+          } else {
+            element = await page.$(selector);
+          }
+
+          if (!element) {
+            return {
+              success: true,
+              found: false,
+              message: `未找到元素: ${selector}`
+            };
+          }
+
+          // 获取元素信息
+          const box = await element.boundingBox();
+          const info = await page.evaluate((el) => {
+            return {
+              tagName: el.tagName,
+              text: el.innerText?.substring(0, 200) || '',
+              href: el.href || el.src || '',
+              value: el.value || '',
+              checked: el.checked,
+              disabled: el.disabled,
+              visible: el.offsetParent !== null
+            };
+          }, element);
+
+          return {
+            success: true,
+            found: true,
+            selector: selector,
+            boundingBox: box,
+            ...info
+          };
+        }
+      },
+
+      // 查找所有匹配元素
+      element_find_all: {
+        description: '查找所有匹配的元素',
+        inputSchema: z.object({
+          selector: z.string().describe('CSS选择器或XPath'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          let elements;
+          let isXPath = args.selector.startsWith('//') || args.selector.startsWith('/');
+
+          if (isXPath) {
+            elements = await page.$x(args.selector);
+          } else {
+            elements = await page.$$(args.selector);
+          }
+
+          const results = [];
+          for (let i = 0; i < Math.min(elements.length, 50); i++) {
+            const info = await page.evaluate((el) => ({
+              text: el.innerText?.substring(0, 100) || '',
+              href: el.href || '',
+              alt: el.alt || '',
+              title: el.title || ''
+            }), elements[i]);
+            results.push({ index: i, ...info });
+          }
+
+          return {
+            success: true,
+            count: elements.length,
+            displayed: results.length,
+            elements: results
+          };
+        }
+      },
+
+      // 点击元素
+      element_click: {
+        description: '点击页面元素',
+        inputSchema: z.object({
+          selector: z.string().describe('CSS选择器或XPath'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+          button: z.enum(['left', 'right', 'middle']).optional().describe('鼠标按钮'),
+          clickCount: z.number().optional().describe('点击次数'),
+          delay: z.number().optional().describe('点击后延迟(ms)'),
+          force: z.boolean().optional().describe('强制点击（可点击隐藏元素）'),
+          timeout: z.number().optional().describe('等待元素超时(ms)，默认10000'),
+          scrollIntoView: z.boolean().optional().describe('是否滚动到视口，默认true'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const timeout = args.timeout || 10000;
+          const selector = args.selector;
+          
+          // 改进 XPath 检测：支持 // 和 / 开头
+          const isXPath = selector.startsWith('//') || selector.startsWith('/');
+
+          try {
+            let element;
+            
+            if (isXPath) {
+              // XPath 模式：先等待元素，然后使用 page.evaluate 点击
+              await page.waitForXPath(selector, { timeout, visible: !args.force });
+              const elements = await page.$x(selector);
+              element = elements[0];
+              
+              if (!element) {
+                throw new Error(`未找到元素: ${selector}`);
+              }
+              
+              // 使用 page.click 支持的选项
+              if (args.scrollIntoView !== false) {
+                await element.evaluate(el => el.scrollIntoViewIfNeeded());
+              }
+              
+              // 通过 evaluate 模拟点击，避免 visibility 检查问题
+              const clickOptions = {
+                button: args.button || 'left',
+                clickCount: args.clickCount || 1
+              };
+              await page.evaluate(({ el, options }) => {
+                const rect = el.getBoundingClientRect();
+                const event = new MouseEvent('click', {
+                  view: window,
+                  bubbles: true,
+                  cancelable: true,
+                  button: options.button === 'right' ? 2 : options.button === 'middle' ? 1 : 0,
+                  buttons: 1,
+                  clientX: rect.left + rect.width / 2,
+                  clientY: rect.top + rect.height / 2,
+                  detail: options.clickCount || 1
+                });
+                el.dispatchEvent(event);
+              }, { el: element, options: clickOptions });
+            } else {
+              // CSS 选择器模式：使用 page.click，它会自动处理元素可见性和滚动
+              const clickOptions = {
+                button: args.button || 'left',
+                clickCount: args.clickCount || 1,
+                delay: 0,
+                timeout: timeout,
+                force: args.force || false
+              };
+              
+              // 如果不是强制点击，设置 hidden 为 false
+              if (!args.force) {
+                clickOptions.visible = true;
+              }
+              
+              await page.click(selector, clickOptions);
+            }
+
+            if (args.delay) {
+              await new Promise(r => setTimeout(r, args.delay));
+            }
+
+            return {
+              success: true,
+              message: `已点击: ${selector}`,
+              url: page.url()
+            };
+          } catch (error) {
+            // 提供更详细的错误信息
+            if (error.message.includes('not visible') || error.message.includes('not displayed')) {
+              throw new Error(`元素不可见或被遮挡: ${selector}。可尝试设置 force: true 强制点击，或检查元素是否正确渲染。`);
+            }
+            if (error.message.includes('not found') || error.message.includes('not exist')) {
+              throw new Error(`未找到元素: ${selector}。请确认选择器正确，元素已加载。`);
+            }
+            if (error.message.includes('timeout')) {
+              throw new Error(`等待元素超时: ${selector} (${timeout}ms)。请检查元素是否存在或增加 timeout 值。`);
+            }
+            throw error;
+          }
+        }
+      },
+
+      // 输入文本
+      element_type: {
+        description: '向输入框输入文本',
+        inputSchema: z.object({
+          selector: z.string().describe('CSS选择器或XPath'),
+          text: z.string().describe('输入的文本'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+          delay: z.number().optional().describe('每个字符延迟(ms)'),
+          clear: z.boolean().optional().describe('输入前清空内容'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          let element;
+          let isXPath = args.selector.startsWith('//') || args.selector.startsWith('/');
+
+          if (isXPath) {
+            const elements = await page.$x(args.selector);
+            element = elements[0];
+          } else {
+            element = await page.$(args.selector);
+          }
+
+          if (!element) {
+            throw new Error(`未找到元素: ${args.selector}`);
+          }
+
+          if (args.clear) {
+            await element.click({ clickCount: 3 });
+            await page.keyboard.press('ControlOrMeta+A');
+            await page.keyboard.press('Backspace');
+          }
+
+          await element.type(args.text, { delay: args.delay || 0 });
+
+          return {
+            success: true,
+            message: `已输入文本到: ${args.selector}`,
+            textLength: args.text.length
+          };
+        }
+      },
+
+      // 按键操作
+      element_press: {
+        description: '模拟键盘按键',
+        inputSchema: z.object({
+          key: z.string().describe('按键名称，如 Enter, Escape, Backspace'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+          modifiers: z.array(z.enum(['Control', 'Shift', 'Alt', 'Meta'])).optional().describe('组合键修饰符'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const modifiers = args.modifiers || [];
+
+          if (modifiers.length > 0) {
+            await page.keyboard.down(modifiers[0]);
+            await page.keyboard.press(args.key);
+            await page.keyboard.up(modifiers[0]);
+          } else {
+            await page.keyboard.press(args.key);
+          }
+
+          return {
+            success: true,
+            message: `已按下: ${[...modifiers, args.key].join('+')}`
+          };
+        }
+      },
+
+      // 悬停
+      element_hover: {
+        description: '鼠标悬停到元素',
+        inputSchema: z.object({
+          selector: z.string().describe('CSS选择器或XPath'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          let element;
+          let isXPath = args.selector.startsWith('//') || args.selector.startsWith('/');
+
+          if (isXPath) {
+            const elements = await page.$x(args.selector);
+            element = elements[0];
+          } else {
+            element = await page.$(args.selector);
+          }
+
+          if (!element) {
+            throw new Error(`未找到元素: ${args.selector}`);
+          }
+
+          await element.hover();
+
+          return {
+            success: true,
+            message: `已悬停: ${args.selector}`
+          };
+        }
+      },
+
+      // 等待元素
+      element_wait: {
+        description: '等待元素出现或消失',
+        inputSchema: z.object({
+          selector: z.string().describe('CSS选择器或XPath'),
+          state: z.enum(['attached', 'detached', 'visible', 'hidden']).optional().describe('等待状态'),
+          timeout: z.number().optional().describe('超时时间(ms)'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const options = {
+            timeout: args.timeout || 30000,
+            visible: args.state === 'visible',
+            hidden: args.state === 'hidden'
+          };
+
+          let selector = args.selector;
+          if (!selector.startsWith('//') && !selector.startsWith('/') && !selector.startsWith('#') &&
+              !selector.startsWith('.') && !selector.startsWith('[')) {
+            selector = args.selector;
+          }
+
+          await page.waitForSelector(selector, options);
+
+          return {
+            success: true,
+            message: `元素已${args.state || '可见'}: ${args.selector}`
+          };
+        }
+      },
+
+      // ============ JavaScript ============
+
+      // 执行JavaScript
+      js_execute: {
+        description: '在页面中执行JavaScript代码',
+        inputSchema: z.object({
+          code: z.string().describe('JavaScript代码（可使用 async/await）'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          try {
+            const result = await page.evaluate(args.code);
+            return {
+              success: true,
+              result: result,
+              type: typeof result
+            };
+          } catch (error) {
+            return {
+              success: false,
+              error: error.message
+            };
+          }
+        }
+      },
+
+      // ============ Cookie管理 ============
+
+      // 获取Cookie
+      cookie_get: {
+        description: '获取页面Cookie',
+        inputSchema: z.object({
+          name: z.string().optional().describe('指定Cookie名称，不填则获取所有'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const cookies = await page.cookies();
+
+          if (args.name) {
+            const cookie = cookies.find(c => c.name === args.name);
+            return {
+              success: true,
+              cookie: cookie || null,
+              message: cookie ? `找到Cookie: ${args.name}` : `未找到Cookie: ${args.name}`
+            };
+          }
+
+          return {
+            success: true,
+            cookies: cookies,
+            count: cookies.length
+          };
+        }
+      },
+
+      // 设置Cookie
+      cookie_set: {
+        description: '设置Cookie',
+        inputSchema: z.object({
+          name: z.string().describe('Cookie名称'),
+          value: z.string().describe('Cookie值'),
+          domain: z.string().optional().describe('域名'),
+          path: z.string().optional().describe('路径'),
+          expires: z.number().optional().describe('过期时间戳'),
+          httpOnly: z.boolean().optional().describe('是否HttpOnly'),
+          secure: z.boolean().optional().describe('是否仅HTTPS'),
+          sameSite: z.enum(['Strict', 'Lax', 'None']).optional().describe('SameSite策略'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          const cookie = {
+            name: args.name,
+            value: args.value
+          };
+
+          if (args.domain) cookie.domain = args.domain;
+          if (args.path) cookie.path = args.path;
+          if (args.expires) cookie.expires = args.expires;
+          if (args.httpOnly !== undefined) cookie.httpOnly = args.httpOnly;
+          if (args.secure !== undefined) cookie.secure = args.secure;
+          if (args.sameSite) cookie.sameSite = args.sameSite;
+
+          await page.setCookie(cookie);
+
+          return {
+            success: true,
+            message: `已设置Cookie: ${args.name}`,
+            cookie: cookie
+          };
+        }
+      },
+
+      // 清除Cookie
+      cookie_clear: {
+        description: '清除Cookie',
+        inputSchema: z.object({
+          name: z.string().optional().describe('指定Cookie名称，不填则清除所有'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          if (args.name) {
+            await page.deleteCookie({ name: args.name });
+            return {
+              success: true,
+              message: `已删除Cookie: ${args.name}`
+            };
+          }
+
+          const cookies = await page.cookies();
+          await page.deleteCookie(...cookies);
+
+          return {
+            success: true,
+            message: '已清除所有Cookie',
+            count: cookies.length
+          };
+        }
+      },
+
+      // ============ Session管理 ============
+
+      // 保存Session
+      session_save: {
+        description: '保存当前浏览器会话状态',
+        inputSchema: z.object({
+          name: z.string().describe('Session名称'),
+          includeCookies: z.boolean().optional().describe('是否包含Cookie'),
+          includeStorage: z.boolean().optional().describe('是否包含LocalStorage'),
+        }),
+        execute: async (args) => {
+          if (!this.browser) {
+            throw new Error('浏览器未启动');
+          }
+
+          const sessionPath = path.join(SESSION_DIR, `${args.name}.json`);
+          const sessionData = {
+            name: args.name,
+            timestamp: Date.now(),
+            url: null,
+            cookies: null,
+            storage: null
+          };
+
+          const pages = await this.browser.pages();
+          if (pages.length > 0) {
+            sessionData.url = pages[0].url();
+          }
+
+          if (args.includeCookies !== false && pages.length > 0) {
+            sessionData.cookies = await pages[0].cookies();
+          }
+
+          if (args.includeStorage && pages.length > 0) {
+            sessionData.storage = await pages[0].evaluate(() => {
+              return {
+                localStorage: { ...localStorage },
+                sessionStorage: { ...sessionStorage }
+              };
+            });
+          }
+
+          const fs = require('fs');
+          fs.writeFileSync(sessionPath, JSON.stringify(sessionData, null, 2));
+
+          return {
+            success: true,
+            message: `Session已保存: ${args.name}`,
+            path: sessionPath,
+            size: Buffer.byteLength(JSON.stringify(sessionData))
+          };
+        }
+      },
+
+      // 加载Session
+      session_load: {
+        description: '加载并恢复浏览器会话状态',
+        inputSchema: z.object({
+          name: z.string().describe('Session名称'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const sessionPath = path.join(SESSION_DIR, `${args.name}.json`);
+          const fs = require('fs');
+
+          if (!fs.existsSync(sessionPath)) {
+            throw new Error(`Session不存在: ${args.name}`);
+          }
+
+          const sessionData = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+
+          if (!this.browser) {
+            throw new Error('浏览器未启动');
+          }
+
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          // 恢复Cookie
+          if (sessionData.cookies && sessionData.cookies.length > 0) {
+            await page.setCookie(...sessionData.cookies);
+          }
+
+          // 恢复LocalStorage
+          if (sessionData.storage?.localStorage) {
+            await page.evaluate((storage) => {
+              for (const [key, value] of Object.entries(storage)) {
+                localStorage.setItem(key, value);
+              }
+            }, sessionData.storage.localStorage);
+          }
+
+          // 导航到保存的URL
+          if (sessionData.url) {
+            await page.goto(sessionData.url, { waitUntil: 'networkidle2' });
+          }
+
+          return {
+            success: true,
+            message: `Session已加载: ${args.name}`,
+            url: sessionData.url,
+            cookiesCount: sessionData.cookies?.length || 0
+          };
+        }
+      },
+
+      // 列出Session
+      session_list: {
+        description: '列出所有保存的Session',
+        inputSchema: z.object({}),
+        execute: async () => {
+          const fs = require('fs');
+
+          if (!fs.existsSync(SESSION_DIR)) {
+            return {
+              success: true,
+              sessions: [],
+              message: '暂无保存的Session'
+            };
+          }
+
+          const files = fs.readdirSync(SESSION_DIR)
+            .filter(f => f.endsWith('.json'));
+
+          const sessions = files.map(f => {
+            const data = JSON.parse(fs.readFileSync(path.join(SESSION_DIR, f), 'utf8'));
+            return {
+              name: data.name,
+              timestamp: data.timestamp,
+              url: data.url,
+              cookiesCount: data.cookies?.length || 0,
+              hasStorage: !!data.storage
+            };
+          });
+
+          return {
+            success: true,
+            sessions: sessions,
+            count: sessions.length
+          };
+        }
+      },
+
+      // 删除Session
+      session_delete: {
+        description: '删除指定的Session',
+        inputSchema: z.object({
+          name: z.string().describe('Session名称'),
+        }),
+        execute: async (args) => {
+          const sessionPath = path.join(SESSION_DIR, `${args.name}.json`);
+          const fs = require('fs');
+
+          if (!fs.existsSync(sessionPath)) {
+            throw new Error(`Session不存在: ${args.name}`);
+          }
+
+          fs.unlinkSync(sessionPath);
+
+          return {
+            success: true,
+            message: `已删除Session: ${args.name}`
+          };
+        }
+      },
+
+      // ============ 等待 ============
+
+      // 等待指定时间
+      wait: {
+        description: '等待指定时间',
+        inputSchema: z.object({
+          milliseconds: z.number().describe('等待时间(毫秒)'),
+        }),
+        execute: async (args) => {
+          await new Promise(r => setTimeout(r, args.milliseconds));
+          return {
+            success: true,
+            waited: args.milliseconds
+          };
+        }
+      },
+
+      // 等待网络空闲
+      wait_network_idle: {
+        description: '等待网络空闲',
+        inputSchema: z.object({
+          timeout: z.number().optional().describe('超时时间(ms)'),
+          pageId: z.string().optional().describe('页面ID，默认当前页面'),
+        }),
+        execute: async (args) => {
+          const page = args.pageId && this.pages.has(args.pageId)
+            ? this.pages.get(args.pageId)
+            : this.getCurrentPage();
+
+          await page.waitForNetworkIdle({ timeout: args.timeout || 30000 });
+
+          return {
+            success: true,
+            message: '网络已空闲',
+            url: page.url()
+          };
+        }
+      }
+    };
+
+    // 生命周期方法
+    install(framework) {
+      return this;
+    }
+
+    async start(framework) {
+      console.log('Puppeteer 插件已启动');
+    }
+
+    async uninstall(framework) {
+      // 关闭浏览器
+      if (this.browser) {
+        await this.browser.close();
+        this.browser = null;
+        this.pages.clear();
+      }
+    }
+  };
+};