myagent-ai 1.2.2 → 1.3.1

package/skills/browser_skill.py

@@ -1,11 +1,24 @@
 """
-skills/browser_skill.py - 浏览器操作技能
-=========================================
-提供浏览器自动化操作功能(使用 Playwright)。
+skills/browser_skill.py - 浏览器自动化技能 (完整版)
+===================================================
+基于 Playwright 的完整浏览器自动化，支持持久会话、多标签页、JS 执行、截图等。
+所有浏览器技能共享同一个浏览器实例，实现跨操作的持久会话。
+
+Skills:
+  - BrowserOpenSkill: 打开 URL，返回结构化页面信息
+  - BrowserClickSkill: 通过 CSS/文本选择器点击元素
+  - BrowserFillSkill: 通过 CSS/文本选择器填写输入框
+  - BrowserScreenshotSkill: 截取当前页面截图，返回路径供 VLM 分析
+  - BrowserEvalSkill: 在页面上执行 JavaScript
+  - BrowserNavigateSkill: 浏览器导航（前进、后退、新标签页）
+  - BrowserCloseSkill: 关闭当前页面或浏览器
 """
 from __future__ import annotations
 
-from typing import Optional, List
+import asyncio
+import os
+import time
+from typing import Any, Dict, List, Optional
 
 from core.logger import get_logger
 from skills.base import Skill, SkillResult, SkillParameter
@@ -13,134 +26,745 @@ from skills.base import Skill, SkillResult, SkillParameter
 logger = get_logger("myagent.skills.browser")
 
 
+class BrowserSession:
+    """
+    浏览器持久会话管理器。
+
+    使用类级别变量在所有浏览器技能之间共享同一个浏览器实例。
+    支持懒初始化（首次使用时才启动浏览器）。
+    所有方法使用 asyncio.Lock 保证并发安全。
+    """
+
+    _browser: Any = None          # Playwright Browser 实例
+    _playwright: Any = None       # Playwright 实例
+    _pages: Dict[str, Any] = {}   # page_id -> Page 映射 (多标签页支持)
+    _active_page_id: str = ""     # 当前活跃页面 ID
+    _lock: Optional[asyncio.Lock] = None
+
+    @classmethod
+    def _get_lock(cls) -> asyncio.Lock:
+        """获取或创建异步锁（线程安全的懒初始化）"""
+        if cls._lock is None:
+            cls._lock = asyncio.Lock()
+        return cls._lock
+
+    @classmethod
+    async def get_browser(cls) -> Any:
+        """
+        获取浏览器实例（懒初始化）。
+        首次调用时启动 Chromium 浏览器，后续调用复用已有实例。
+        """
+        from playwright.async_api import async_playwright
+
+        async with cls._get_lock():
+            if cls._browser is None or not cls._browser.is_connected():
+                cls._playwright = await async_playwright().start()
+                cls._browser = await cls._playwright.chromium.launch(
+                    headless=True,
+                    args=["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"],
+                )
+                logger.info("浏览器实例已启动 (Chromium, headless)")
+        return cls._browser
+
+    @classmethod
+    async def get_page(cls, page_id: str = "default") -> Any:
+        """
+        获取指定 ID 的页面。如果不存在则自动创建。
+        默认使用 'default' 页面 ID。
+        """
+        browser = await cls.get_browser()
+        async with cls._get_lock():
+            if page_id not in cls._pages:
+                page = await browser.new_page()
+                # 设置合理的默认超时和视口
+                page.set_default_timeout(30000)
+                page.set_default_navigation_timeout(30000)
+                cls._pages[page_id] = page
+                cls._active_page_id = page_id
+                logger.info(f"新标签页已创建: {page_id}")
+            cls._active_page_id = page_id
+        return cls._pages[page_id]
+
+    @classmethod
+    async def get_active_page(cls) -> tuple[Any, str]:
+        """获取当前活跃页面及其 ID"""
+        if not cls._active_page_id or cls._active_page_id not in cls._pages:
+            page = await cls.get_page("default")
+            return page, "default"
+        return cls._pages[cls._active_page_id], cls._active_page_id
+
+    @classmethod
+    async def close_page(cls, page_id: str = "") -> SkillResult:
+        """关闭指定页面。如果未指定则关闭当前活跃页面。"""
+        async with cls._get_lock():
+            if not page_id:
+                page_id = cls._active_page_id
+
+            if page_id and page_id in cls._pages:
+                await cls._pages[page_id].close()
+                del cls._pages[page_id]
+                logger.info(f"标签页已关闭: {page_id}")
+
+                # 如果关闭的是当前活跃页面，切换到其他页面
+                if page_id == cls._active_page_id:
+                    remaining = list(cls._pages.keys())
+                    cls._active_page_id = remaining[0] if remaining else ""
+                    return SkillResult(
+                        success=True,
+                        message=f"标签页 '{page_id}' 已关闭，当前活跃: {cls._active_page_id or '无'}",
+                        data={"remaining_tabs": list(cls._pages.keys())},
+                    )
+                return SkillResult(
+                    success=True,
+                    message=f"标签页 '{page_id}' 已关闭",
+                    data={"remaining_tabs": list(cls._pages.keys())},
+                )
+            return SkillResult(success=False, error="没有可关闭的页面")
+
+    @classmethod
+    async def close_browser(cls) -> SkillResult:
+        """关闭整个浏览器及所有页面。"""
+        async with cls._get_lock():
+            if cls._pages:
+                for pid, page in cls._pages.items():
+                    try:
+                        await page.close()
+                    except Exception:
+                        pass
+                cls._pages.clear()
+                cls._active_page_id = ""
+
+            if cls._browser:
+                await cls._browser.close()
+                cls._browser = None
+                logger.info("浏览器实例已关闭")
+
+            if cls._playwright:
+                await cls._playwright.stop()
+                cls._playwright = None
+
+            return SkillResult(success=True, message="浏览器已完全关闭")
+
+    @classmethod
+    def _generate_screenshot_path(cls) -> str:
+        """生成截图文件路径（带时间戳）"""
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        path = f"/tmp/myagent_gui_screenshot_{timestamp}.png"
+        return path
+
+
 class BrowserOpenSkill(Skill):
-    """打开网页"""
+    """
+    打开网页 - 打开指定 URL 并返回结构化的页面信息。
+
+    如果浏览器尚未启动，会自动启动。如果已有页面，在当前页面导航。
+    返回页面的标题、可见文本、链接列表、表单信息等结构化数据。
+    """
+
     name = "browser_open"
-    description = "使用无头浏览器打开指定 URL，返回页面内容"
+    description = (
+        "使用浏览器打开指定 URL，返回页面的结构化信息（标题、可见文本、链接、表单等）。"
+        "浏览器会保持持久会话，后续操作可在同一页面继续。"
+    )
     category = "browser"
     parameters = [
-        SkillParameter("url", "string", "要打开的 URL", required=True),
-        SkillParameter("wait", "integer", "等待时间(毫秒)", required=False, default=3000),
-        SkillParameter("screenshot", "boolean", "是否截图", required=False, default=False),
+        SkillParameter("url", "string", "要打开的网页 URL（必须以 http:// 或 https:// 开头）", required=True),
+        SkillParameter("wait", "integer", "页面加载后额外等待时间（毫秒），用于等待动态内容渲染", required=False, default=3000),
+        SkillParameter("page_id", "string", "在指定标签页打开（留空则使用当前活跃标签页）", required=False, default=""),
+        SkillParameter("wait_until", "string", "导航等待策略: domcontentloaded/load/networkidle/commit", required=False, default="domcontentloaded",
+                        enum=["domcontentloaded", "load", "networkidle", "commit"]),
     ]
 
-    async def execute(self, url: str = "", wait: int = 3000,
-                      screenshot: bool = False, **kwargs) -> SkillResult:
+    async def execute(
+        self,
+        url: str = "",
+        wait: int = 3000,
+        page_id: str = "",
+        wait_until: str = "domcontentloaded",
+        **kwargs,
+    ) -> SkillResult:
+        """执行：打开 URL 并提取页面结构化信息"""
         try:
             from playwright.async_api import async_playwright
+        except ImportError:
+            # 自动安装缺失依赖
+            from core.deps_checker import ensure_skill_deps
+            if not ensure_skill_deps("browser"):
+                return SkillResult(
+                    success=False,
+                    error="Playwright 安装失败，请手动运行: pip install playwright && playwright install chromium",
+                )
+            from playwright.async_api import async_playwright
 
-            async with async_playwright() as p:
-                browser = await p.chromium.launch(headless=True)
-                page = await browser.new_page()
+        if not url:
+            return SkillResult(success=False, error="缺少必需参数: url")
 
-                await page.goto(url, wait_until="networkidle", timeout=30000)
-                if wait > 0:
-                    await page.wait_for_timeout(wait)
+        try:
+            page = await BrowserSession.get_page(page_id or "default")
 
-                # 提取页面内容
-                title = await page.title()
-                content = await page.content()
-                # 纯文本
-                text = await page.evaluate("() => document.body.innerText")
+            # 导航到目标 URL
+            await page.goto(url, wait_until=wait_until, timeout=30000)
 
-                result_data = {
-                    "url": url,
-                    "title": title,
-                    "text_content": text[:15000],
-                }
+            # 等待动态内容渲染
+            if wait > 0:
+                await page.wait_for_timeout(wait)
 
-                # 截图
-                if screenshot:
-                    ss_path = f"/tmp/screenshot_{url.replace('/', '_')[:50]}.png"
-                    await page.screenshot(path=ss_path, full_page=True)
-                    result_data["screenshot_path"] = ss_path
+            # 提取结构化页面信息
+            page_info = await page.evaluate("""() => {
+                // 提取可见文本（去除隐藏元素）
+                const allText = document.body ? document.body.innerText : '';
 
-                await browser.close()
+                // 提取所有链接
+                const links = Array.from(document.querySelectorAll('a[href]'))
+                    .filter(a => a.offsetParent !== null)  // 只取可见链接
+                    .slice(0, 50)
+                    .map(a => ({
+                        text: a.innerText.trim().substring(0, 100),
+                        href: a.href,
+                    }))
+                    .filter(l => l.text);
+
+                // 提取表单信息
+                const forms = Array.from(document.querySelectorAll('form'))
+                    .slice(0, 20)
+                    .map(form => {
+                        const inputs = Array.from(form.querySelectorAll('input, textarea, select'))
+                            .map(el => ({
+                                tag: el.tagName.toLowerCase(),
+                                type: el.type || '',
+                                name: el.name || '',
+                                placeholder: el.placeholder || '',
+                                id: el.id || '',
+                            }));
+                        return {
+                            action: form.action || '',
+                            method: (form.method || 'GET').toUpperCase(),
+                            inputs: inputs.slice(0, 20),
+                        };
+                    });
+
+                // 提取标题层级（用于理解页面结构）
+                const headings = Array.from(document.querySelectorAll('h1, h2, h3, h4'))
+                    .map(h => ({
+                        tag: h.tagName,
+                        text: h.innerText.trim().substring(0, 200),
+                    }))
+                    .filter(h => h.text)
+                    .slice(0, 20);
+
+                return {
+                    title: document.title || '',
+                    text: allText.substring(0, 20000),
+                    links: links,
+                    forms: forms,
+                    headings: headings,
+                    url: window.location.href,
+                };
+            }""")
 
-                return SkillResult(
-                    success=True,
-                    data=result_data,
-                    message=f"已打开: {title} ({len(text)} 字符)",
-                    files=result_data.get("screenshot_path", []),
-                )
-        except ImportError:
             return SkillResult(
-                success=False,
-                error="请安装 Playwright: pip install playwright && playwright install chromium",
+                success=True,
+                data=page_info,
+                message=f"已打开: {page_info.get('title', '未知页面')} (文本 {len(page_info.get('text', ''))} 字符, {len(page_info.get('links', []))} 个链接)",
             )
         except Exception as e:
-            return SkillResult(success=False, error=f"浏览器操作失败: {e}")
+            logger.error(f"浏览器打开失败: {e}")
+            return SkillResult(success=False, error=f"浏览器打开失败: {e}")
 
 
 class BrowserClickSkill(Skill):
-    """点击页面元素"""
+    """
+    点击页面元素 - 通过 CSS 选择器或可见文本定位并点击元素。
+
+    支持两种定位方式:
+      1. CSS 选择器: selector="button.submit-btn"
+      2. 文本匹配: text="登录" 或 text="Submit"
+    如果同时提供 selector 和 text，优先使用 selector。
+    """
+
     name = "browser_click"
-    description = "在浏览器页面中点击指定元素"
+    description = (
+        "在当前浏览器页面中点击元素。支持 CSS 选择器（selector）或可见文本（text）定位。"
+        "点击后会等待 1 秒让页面响应。"
+    )
     category = "browser"
     parameters = [
-        SkillParameter("selector", "string", "CSS 选择器", required=True),
-        SkillParameter("url", "string", "页面 URL(如果未打开)", required=False, default=""),
+        SkillParameter("selector", "string", "目标元素的 CSS 选择器（如 'button#submit', 'a.login-link', 'input[type=submit]'）", required=False, default=""),
+        SkillParameter("text", "string", "目标元素的可见文本（如 '登录', '搜索', 'Submit'）", required=False, default=""),
+        SkillParameter("wait_after", "integer", "点击后等待时间（毫秒），用于等待页面响应", required=False, default=1000),
+        SkillParameter("double_click", "boolean", "是否双击（默认单击）", required=False, default=False),
     ]
 
-    async def execute(self, selector: str = "", url: str = "", **kwargs) -> SkillResult:
+    async def execute(
+        self,
+        selector: str = "",
+        text: str = "",
+        wait_after: int = 1000,
+        double_click: bool = False,
+        **kwargs,
+    ) -> SkillResult:
+        """执行：定位并点击页面元素"""
         try:
             from playwright.async_api import async_playwright
+        except ImportError:
+            from core.deps_checker import ensure_skill_deps
+            if not ensure_skill_deps("browser"):
+                return SkillResult(
+                    success=False,
+                    error="Playwright 安装失败，请手动运行: pip install playwright && playwright install chromium",
+                )
+            from playwright.async_api import async_playwright
 
-            async with async_playwright() as p:
-                browser = await p.chromium.launch(headless=True)
-                page = await browser.new_page()
+        if not selector and not text:
+            return SkillResult(success=False, error="必须提供 selector 或 text 参数来定位元素")
 
-                if url:
-                    await page.goto(url, wait_until="networkidle", timeout=30000)
+        try:
+            page, page_id = await BrowserSession.get_active_page()
 
-                await page.click(selector, timeout=10000)
-                await page.wait_for_timeout(2000)
+            # 定位元素
+            if selector:
+                # CSS 选择器定位
+                element = page.locator(selector).first
+                await element.wait_for(state="visible", timeout=10000)
+                if double_click:
+                    await element.dblclick()
+                else:
+                    await element.click()
+            else:
+                # 文本匹配定位（使用 Playwright 的 text 选择器）
+                text_selector = f"text={text}"
+                element = page.locator(text_selector).first
+                await element.wait_for(state="visible", timeout=10000)
+                if double_click:
+                    await element.dblclick()
+                else:
+                    await element.click()
 
-                text = await page.evaluate("() => document.body.innerText")
-                title = await page.title()
+            # 等待页面响应
+            if wait_after > 0:
+                await page.wait_for_timeout(wait_after)
 
-                await browser.close()
+            # 获取点击后的页面状态
+            title = await page.title()
+            visible_text = await page.evaluate("() => document.body.innerText.substring(0, 3000)")
 
-                return SkillResult(
-                    success=True,
-                    data={"title": title, "text": text[:10000]},
-                    message=f"已点击: {selector}",
-                )
+            click_desc = f"双击" if double_click else "点击"
+            loc_desc = f"选择器 '{selector}'" if selector else f"文本 '{text}'"
+
+            return SkillResult(
+                success=True,
+                data={"title": title, "text_preview": visible_text},
+                message=f"已{click_desc} {loc_desc}，当前页面: {title}",
+            )
         except Exception as e:
-            return SkillResult(success=False, error=str(e))
+            logger.error(f"点击元素失败: {e}")
+            return SkillResult(
+                success=False,
+                error=f"点击元素失败: {e}（请检查选择器 '{selector}' 或文本 '{text}' 是否正确）",
+            )
 
 
 class BrowserFillSkill(Skill):
-    """填写表单"""
+    """
+    填写输入框 - 通过 CSS 选择器或可见文本定位输入框并填入内容。
+
+    支持 <input>, <textarea>, <select> 以及 contenteditable 元素。
+    填写前会先清空原有内容，确保填写结果的准确性。
+    """
+
     name = "browser_fill"
-    description = "在浏览器页面中填写表单字段"
+    description = (
+        "在当前浏览器页面的输入框中填写内容。支持 CSS 选择器（selector）或文本标签定位。"
+        "填写前会自动清空原有内容。"
+    )
     category = "browser"
     parameters = [
-        SkillParameter("selector", "string", "输入框 CSS 选择器", required=True),
-        SkillParameter("value", "string", "要填写的值", required=True),
-        SkillParameter("url", "string", "页面 URL", required=False, default=""),
+        SkillParameter("selector", "string", "输入框的 CSS 选择器（如 'input#username', 'textarea[name=content]'）", required=False, default=""),
+        SkillParameter("text", "string", "输入框关联的可见文本标签（如 '用户名', 'Email'）", required=False, default=""),
+        SkillParameter("value", "string", "要填写的值（文本内容）", required=True),
+        SkillParameter("clear_first", "boolean", "是否先清空输入框（默认 true）", required=False, default=True),
+        SkillParameter("press_enter", "boolean", "填写后是否按回车键（默认 false）", required=False, default=False),
     ]
 
-    async def execute(self, selector: str = "", value: str = "",
-                      url: str = "", **kwargs) -> SkillResult:
+    async def execute(
+        self,
+        selector: str = "",
+        text: str = "",
+        value: str = "",
+        clear_first: bool = True,
+        press_enter: bool = False,
+        **kwargs,
+    ) -> SkillResult:
+        """执行：定位输入框并填写内容"""
         try:
             from playwright.async_api import async_playwright
+        except ImportError:
+            from core.deps_checker import ensure_skill_deps
+            if not ensure_skill_deps("browser"):
+                return SkillResult(
+                    success=False,
+                    error="Playwright 安装失败，请手动运行: pip install playwright && playwright install chromium",
+                )
+            from playwright.async_api import async_playwright
 
-            async with async_playwright() as p:
-                browser = await p.chromium.launch(headless=True)
-                page = await browser.new_page()
+        if not value:
+            return SkillResult(success=False, error="缺少必需参数: value")
+        if not selector and not text:
+            return SkillResult(success=False, error="必须提供 selector 或 text 参数来定位输入框")
 
-                if url:
-                    await page.goto(url, wait_until="networkidle", timeout=30000)
+        try:
+            page, page_id = await BrowserSession.get_active_page()
+
+            if selector:
+                element = page.locator(selector).first
+                await element.wait_for(state="visible", timeout=10000)
+            else:
+                # 通过文本标签查找关联的输入框
+                # 尝试找到包含该文本的 label，然后找到 label for 指向的 input
+                element = await page.evaluate_handle(f"""(text) => {{
+                    // 方式1: 查找 label 标签
+                    const labels = Array.from(document.querySelectorAll('label'));
+                    for (const label of labels) {{
+                        if (label.innerText.trim().includes(text)) {{
+                            if (label.htmlFor) {{
+                                return document.getElementById(label.htmlFor) || label.querySelector('input, textarea, select');
+                            }}
+                            return label.querySelector('input, textarea, select');
+                        }}
+                    }}
+                    // 方式2: 查找 placeholder 包含文本的输入框
+                    const inputs = Array.from(document.querySelectorAll('input, textarea, select'));
+                    for (const input of inputs) {{
+                        if (input.placeholder && input.placeholder.includes(text)) {{
+                            return input;
+                        }}
+                    }}
+                    return null;
+                }}""", text)
+
+            if element is None:
+                loc_desc = f"选择器 '{selector}'" if selector else f"文本标签 '{text}'"
+                return SkillResult(success=False, error=f"未找到输入框: {loc_desc}")
+
+            # 清空并填写
+            if clear_first:
+                await page.locator(selector).first.fill("") if selector else await element.fill("")
+            await page.locator(selector).first.fill(value) if selector else await element.fill(value)
 
-                await page.fill(selector, value, timeout=10000)
+            # 按回车（可选）
+            if press_enter:
+                await page.locator(selector).first.press("Enter") if selector else await element.press("Enter")
                 await page.wait_for_timeout(1000)
 
-                await browser.close()
+            loc_desc = f"选择器 '{selector}'" if selector else f"文本标签 '{text}'"
+            return SkillResult(
+                success=True,
+                message=f"已在 {loc_desc} 填写内容（{len(value)} 字符）",
+            )
+        except Exception as e:
+            logger.error(f"填写输入框失败: {e}")
+            return SkillResult(success=False, error=f"填写输入框失败: {e}")
+
+
+class BrowserScreenshotSkill(Skill):
+    """
+    页面截图 - 截取当前浏览器页面的截图。
 
+    截图保存到 /tmp/myagent_gui_screenshot_* 路径，返回文件路径。
+    可配合 VLM 技能对截图进行视觉分析。
+    支持全页面截图或仅可视区域截图。
+    """
+
+    name = "browser_screenshot"
+    description = (
+        "截取当前浏览器页面的截图，保存为 PNG 文件并返回文件路径。"
+        "可用于 VLM 视觉分析。支持全页面截图或仅截取可视区域。"
+    )
+    category = "browser"
+    parameters = [
+        SkillParameter("full_page", "boolean", "是否截取整个页面（包括滚动区域），默认仅截取可视区域", required=False, default=False),
+        SkillParameter("selector", "string", "截取特定元素的截图（CSS 选择器），留空则截取整个页面", required=False, default=""),
+    ]
+
+    async def execute(
+        self,
+        full_page: bool = False,
+        selector: str = "",
+        **kwargs,
+    ) -> SkillResult:
+        """执行：截取页面截图"""
+        try:
+            from playwright.async_api import async_playwright
+        except ImportError:
+            from core.deps_checker import ensure_skill_deps
+            if not ensure_skill_deps("browser"):
+                return SkillResult(
+                    success=False,
+                    error="Playwright 安装失败，请手动运行: pip install playwright && playwright install chromium",
+                )
+            from playwright.async_api import async_playwright
+
+        try:
+            page, page_id = await BrowserSession.get_active_page()
+            screenshot_path = BrowserSession._generate_screenshot_path()
+
+            if selector:
+                # 截取特定元素
+                element = page.locator(selector).first
+                await element.wait_for(state="visible", timeout=10000)
+                await element.screenshot(path=screenshot_path)
+            else:
+                # 截取整个页面或可视区域
+                await page.screenshot(path=screenshot_path, full_page=full_page)
+
+            # 获取文件大小
+            file_size = os.path.getsize(screenshot_path)
+
+            return SkillResult(
+                success=True,
+                data={
+                    "screenshot_path": screenshot_path,
+                    "file_size_bytes": file_size,
+                    "full_page": full_page,
+                    "element_selector": selector or None,
+                    "page_title": await page.title(),
+                },
+                message=f"截图已保存: {screenshot_path} ({file_size} 字节)",
+                files=[screenshot_path],
+            )
+        except Exception as e:
+            logger.error(f"截图失败: {e}")
+            return SkillResult(success=False, error=f"截图失败: {e}")
+
+
+class BrowserEvalSkill(Skill):
+    """
+    执行 JavaScript - 在当前浏览器页面中执行自定义 JavaScript 代码。
+
+    可用于提取数据、修改页面状态、与页面交互等高级操作。
+    执行结果以 JSON 格式返回。
+    """
+
+    name = "browser_eval"
+    description = (
+        "在当前浏览器页面中执行 JavaScript 代码并返回结果。"
+        "代码应返回一个可序列化的值（字符串、数字、对象等）。"
+        "可用于提取页面数据、修改 DOM、与页面 API 交互等高级操作。"
+    )
+    category = "browser"
+    dangerous = True
+    parameters = [
+        SkillParameter("code", "string", "要执行的 JavaScript 代码（应包含 return 语句以返回结果）", required=True),
+        SkillParameter("wait_after", "integer", "执行后等待时间（毫秒）", required=False, default=500),
+    ]
+
+    async def execute(
+        self,
+        code: str = "",
+        wait_after: int = 500,
+        **kwargs,
+    ) -> SkillResult:
+        """执行：在页面上运行 JavaScript"""
+        try:
+            from playwright.async_api import async_playwright
+        except ImportError:
+            from core.deps_checker import ensure_skill_deps
+            if not ensure_skill_deps("browser"):
+                return SkillResult(
+                    success=False,
+                    error="Playwright 安装失败，请手动运行: pip install playwright && playwright install chromium",
+                )
+            from playwright.async_api import async_playwright
+
+        if not code:
+            return SkillResult(success=False, error="缺少必需参数: code")
+
+        try:
+            page, page_id = await BrowserSession.get_active_page()
+
+            # 自动包装代码：如果没有 return 语句，将最后一个表达式作为返回值
+            wrapped_code = code.strip()
+            if not wrapped_code.startswith("return"):
+                wrapped_code = f"return (() => {{ {wrapped_code} }})()"
+
+            result = await page.evaluate(wrapped_code)
+
+            return SkillResult(
+                success=True,
+                data={"result": result},
+                message=f"JavaScript 执行成功，返回类型: {type(result).__name__}",
+            )
+        except Exception as e:
+            logger.error(f"JavaScript 执行失败: {e}")
+            return SkillResult(
+                success=False,
+                error=f"JavaScript 执行失败: {e}",
+            )
+
+
+class BrowserNavigateSkill(Skill):
+    """
+    浏览器导航 - 控制浏览器的前进、后退、新标签页等操作。
+
+    支持的导航操作:
+      - back: 后退到上一页
+      - forward: 前进到下一页
+      - new_tab: 打开新标签页（可选指定初始 URL）
+      - switch_tab: 切换到指定标签页
+      - list_tabs: 列出所有打开的标签页
+    """
+
+    name = "browser_navigate"
+    description = (
+        "控制浏览器导航操作：前进、后退、打开新标签页、切换标签页、列出标签页。"
+        "浏览器保持持久会话，标签页之间可自由切换。"
+    )
+    category = "browser"
+    parameters = [
+        SkillParameter("action", "string", "导航操作类型", required=True,
+                        enum=["back", "forward", "new_tab", "switch_tab", "list_tabs"]),
+        SkillParameter("url", "string", "新标签页的 URL（仅 action=new_tab 时有效）", required=False, default=""),
+        SkillParameter("page_id", "string", "目标标签页 ID（仅 switch_tab 时有效）", required=False, default=""),
+    ]
+
+    async def execute(
+        self,
+        action: str = "",
+        url: str = "",
+        page_id: str = "",
+        **kwargs,
+    ) -> SkillResult:
+        """执行：浏览器导航操作"""
+        try:
+            from playwright.async_api import async_playwright
+        except ImportError:
+            from core.deps_checker import ensure_skill_deps
+            if not ensure_skill_deps("browser"):
+                return SkillResult(
+                    success=False,
+                    error="Playwright 安装失败，请手动运行: pip install playwright && playwright install chromium",
+                )
+            from playwright.async_api import async_playwright
+
+        if not action:
+            return SkillResult(success=False, error="缺少必需参数: action")
+
+        try:
+            if action == "back":
+                page, _ = await BrowserSession.get_active_page()
+                await page.go_back(wait_until="domcontentloaded", timeout=15000)
+                title = await page.title()
+                current_url = page.url
+                return SkillResult(
+                    success=True,
+                    data={"title": title, "url": current_url},
+                    message=f"已后退到: {title} ({current_url})",
+                )
+
+            elif action == "forward":
+                page, _ = await BrowserSession.get_active_page()
+                await page.go_forward(wait_until="domcontentloaded", timeout=15000)
+                title = await page.title()
+                current_url = page.url
+                return SkillResult(
+                    success=True,
+                    data={"title": title, "url": current_url},
+                    message=f"已前进到: {title} ({current_url})",
+                )
+
+            elif action == "new_tab":
+                # 生成唯一标签页 ID
+                import uuid
+                new_id = page_id or f"tab_{uuid.uuid4().hex[:8]}"
+                page = await BrowserSession.get_page(new_id)
+                if url:
+                    await page.goto(url, wait_until="domcontentloaded", timeout=30000)
+                title = await page.title()
+                tabs = list(BrowserSession._pages.keys())
                 return SkillResult(
                     success=True,
-                    message=f"已填写 {selector} = {value[:50]}",
+                    data={"page_id": new_id, "title": title, "url": url, "all_tabs": tabs},
+                    message=f"新标签页 '{new_id}' 已打开{f'，已导航到 {url}' if url else ''}",
                 )
+
+            elif action == "switch_tab":
+                if not page_id:
+                    return SkillResult(success=False, error="switch_tab 需要指定 page_id 参数")
+                if page_id not in BrowserSession._pages:
+                    available = list(BrowserSession._pages.keys())
+                    return SkillResult(
+                        success=False,
+                        error=f"标签页 '{page_id}' 不存在。可用标签页: {available}",
+                    )
+                BrowserSession._active_page_id = page_id
+                page = BrowserSession._pages[page_id]
+                title = await page.title()
+                current_url = page.url
+                return SkillResult(
+                    success=True,
+                    data={"page_id": page_id, "title": title, "url": current_url},
+                    message=f"已切换到标签页 '{page_id}': {title}",
+                )
+
+            elif action == "list_tabs":
+                tabs_info = {}
+                for pid, p in BrowserSession._pages.items():
+                    try:
+                        title = await p.title()
+                        tabs_info[pid] = {
+                            "title": title,
+                            "url": p.url,
+                            "is_active": pid == BrowserSession._active_page_id,
+                        }
+                    except Exception:
+                        tabs_info[pid] = {"title": "(无法获取)", "url": "(无法获取)", "is_active": False}
+                return SkillResult(
+                    success=True,
+                    data={"tabs": tabs_info, "active_tab": BrowserSession._active_page_id},
+                    message=f"共 {len(tabs_info)} 个标签页，当前活跃: {BrowserSession._active_page_id}",
+                )
+
+            else:
+                return SkillResult(success=False, error=f"未知导航操作: {action}")
+
+        except Exception as e:
+            logger.error(f"浏览器导航失败: {e}")
+            return SkillResult(success=False, error=f"浏览器导航失败: {e}")
+
+
+class BrowserCloseSkill(Skill):
+    """
+    关闭浏览器 - 关闭当前标签页或整个浏览器。
+
+    关闭标签页后，如果有其他标签页存在，会自动切换到第一个。
+    关闭浏览器会终止所有页面和持久会话。
+    """
+
+    name = "browser_close"
+    description = (
+        "关闭当前浏览器标签页或整个浏览器。"
+        "关闭标签页时，如果有其他标签页会自动切换。"
+        "关闭浏览器会终止所有持久会话。"
+    )
+    category = "browser"
+    parameters = [
+        SkillParameter("target", "string", "关闭目标: 'tab' 关闭当前标签页, 'browser' 关闭整个浏览器", required=False, default="tab",
+                        enum=["tab", "browser"]),
+        SkillParameter("page_id", "string", "要关闭的标签页 ID（留空则关闭当前标签页，仅 target=tab 时有效）", required=False, default=""),
+    ]
+
+    async def execute(
+        self,
+        target: str = "tab",
+        page_id: str = "",
+        **kwargs,
+    ) -> SkillResult:
+        """执行：关闭标签页或浏览器"""
+        try:
+            if target == "browser":
+                return await BrowserSession.close_browser()
+            else:
+                return await BrowserSession.close_page(page_id)
         except Exception as e:
-            return SkillResult(success=False, error=str(e))
+            logger.error(f"关闭浏览器失败: {e}")
+            return SkillResult(success=False, error=f"关闭失败: {e}")