cnks 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

cnks/server.py

@@ -12,11 +12,12 @@ import traceback
 from pathlib import Path
 from urllib.parse import quote
 from typing import Dict, List, Any, Optional, Union
+from datetime import datetime
+from pydantic import BaseModel, AnyUrl
 
 from mcp.server.models import InitializationOptions
 import mcp.types as types
 from mcp.server import NotificationOptions, Server
-from pydantic import AnyUrl
 import mcp.server.stdio
 
 # 配置日志记录
@@ -36,27 +37,38 @@ except ImportError:
     PLAYWRIGHT_AVAILABLE = False
     logger.warning("Playwright未安装，将使用传统方式打开Chrome")
 
+# 定义数据模型
+class CNKIContent(BaseModel):
+    """CNKI论文内容模型"""
+    title: str = ""
+    authors: List[str] = []
+    abstract: str = ""
+    keywords: List[str] = []
+    cite_format: str = ""
+    url: str = ""  # 添加URL字段以记录来源
+
 # 存储当前页面内容和笔记
 page_content = ""
 current_url = ""
 notes: dict[str, str] = {}
-browser_instance = None
 
 server = Server("cnks")
 
-# 导入我们新创建的extractor模块
-try:
-    from . import chrome_extractor as extractor
-except ImportError:
-    try:
-        import chrome_extractor as extractor
-    except ImportError:
-        extractor = None
-        logger.warning("无法导入chrome_extractor模块，批量提取功能将不可用")
+# 添加全局变量来跟踪playwright状态
+playwright_instance = None
+browser_instance = None
+context = None
 
 def find_chrome_executable():
     """查找Chrome可执行文件路径"""
+    # 首先检查环境变量
+    chrome_env = os.environ.get("CHROME_PATH")
+    if chrome_env and os.path.exists(chrome_env):
+        logger.debug(f"[DEBUG] 从环境变量找到Chrome: {chrome_env}")
+        return chrome_env
+        
     system = platform.system()
+    logger.debug(f"[DEBUG] 系统类型: {system}")
     
     # 定义可能的Chrome位置
     if system == "Windows":
@@ -64,48 +76,90 @@ def find_chrome_executable():
             r"C:\Program Files\Google\Chrome\Application\chrome.exe",
             r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
             os.path.expanduser(r"~\AppData\Local\Google\Chrome\Application\chrome.exe"),
+            # Edge浏览器也是基于Chromium的
+            r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
+            r"C:\Program Files\Microsoft\Edge\Application\msedge.exe",
         ]
     elif system == "Darwin":  # MacOS
         chrome_paths = [
             "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
             os.path.expanduser("~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+            "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
         ]
     elif system == "Linux":
         chrome_paths = [
             "/usr/bin/google-chrome",
             "/usr/bin/chromium-browser",
             "/usr/bin/chromium",
+            "/usr/bin/microsoft-edge",
         ]
     else:
+        logger.debug(f"[DEBUG] 未知系统类型: {system}")
         return None
     
     # 检查路径是否存在
     for path in chrome_paths:
         if os.path.exists(path):
+            logger.debug(f"[DEBUG] 找到Chrome: {path}")
             return path
     
-    # 尝试从环境变量中查找
-    chrome_env = os.environ.get("CHROME_PATH")
-    if chrome_env and os.path.exists(chrome_env):
-        return chrome_env
+    # 如果上述路径都不存在，尝试使用which命令查找
+    try:
+        if system != "Windows":
+            # 在Unix系统上尝试使用which命令
+            for browser in ["google-chrome", "chromium", "chromium-browser", "microsoft-edge"]:
+                try:
+                    result = subprocess.check_output(["which", browser], universal_newlines=True).strip()
+                    if result and os.path.exists(result):
+                        logger.debug(f"[DEBUG] 使用which命令找到浏览器: {result}")
+                        return result
+                except subprocess.CalledProcessError:
+                    pass
+        else:
+            # 在Windows上尝试使用where命令
+            try:
+                result = subprocess.check_output(["where", "chrome"], universal_newlines=True).strip()
+                if result:
+                    # where可能返回多行，取第一行
+                    first_path = result.split('\n')[0].strip()
+                    if os.path.exists(first_path):
+                        logger.debug(f"[DEBUG] 使用where命令找到Chrome: {first_path}")
+                        return first_path
+            except subprocess.CalledProcessError:
+                pass
+                
+            # 尝试查找Edge
+            try:
+                result = subprocess.check_output(["where", "msedge"], universal_newlines=True).strip()
+                if result:
+                    first_path = result.split('\n')[0].strip()
+                    if os.path.exists(first_path):
+                        logger.debug(f"[DEBUG] 使用where命令找到Edge: {first_path}")
+                        return first_path
+            except subprocess.CalledProcessError:
+                pass
+    except Exception as e:
+        logger.debug(f"[DEBUG] 使用命令行查找浏览器时出错: {str(e)}")
     
+    logger.debug("[DEBUG] 未找到Chrome或兼容的浏览器")
     return None
 
 def open_chrome(url):
     """打开Chrome浏览器并访问指定URL"""
     try:
-        chrome_path = find_chrome_executable()
+        logger.debug(f"[DEBUG] open_chrome函数被调用，URL: {url}")
         
-        if not chrome_path:
-            return "未找到Chrome可执行文件。请设置CHROME_PATH环境变量指向Chrome位置。"
+        # 使用webbrowser模块打开URL（会使用系统默认浏览器，通常是已经打开的Chrome）
+        logger.debug(f"[DEBUG] 尝试使用webbrowser.open打开URL: {url}")
+        webbrowser.open(url)
+        logger.debug(f"[DEBUG] webbrowser.open调用完成")
         
-        subprocess.Popen([
-            chrome_path, 
-            url
-        ])
-        time.sleep(2)  # 等待页面加载
+        # 等待页面加载
+        time.sleep(2)
+        logger.debug("[DEBUG] open_chrome函数执行完毕")
         return True
     except Exception as e:
+        logger.debug(f"[DEBUG] open_chrome函数出错: {str(e)}")
         return f"打开Chrome时出错: {str(e)}"
 
 async def search_with_playwright(keywords):
@@ -116,234 +170,337 @@ async def search_with_playwright(keywords):
         return "需要安装playwright模块：uv add playwright"
     
     try:
-        chrome_path = find_chrome_executable()
-        if not chrome_path:
-            return "未找到Chrome可执行文件。请设置CHROME_PATH环境变量指向Chrome位置。"
+        logger.debug(f"[DEBUG] 使用搜索功能，关键词: {keywords}")
         
-        logger.debug(f"[DEBUG] 使用Playwright搜索，Chrome路径: {chrome_path}")
+        # 先访问知网首页而不是直接访问搜索结果页
+        initial_url = "https://kns.cnki.net/"
+        search_url = f"https://kns.cnki.net/kns8s/search?q={quote(keywords)}"
+        logger.debug(f"[DEBUG] 初始URL: {initial_url}")
         
-        # 创建全局浏览器实例，避免执行完关闭
-        global browser_instance
+        # 创建全局变量来跟踪playwright状态
+        global playwright_instance, browser_instance, context
         
-        # 只打开一个playwright实例
-        playwright = await async_playwright().start()
+        # 查找Chrome路径
+        chrome_path = find_chrome_executable()
+        if not chrome_path:
+            logger.warning("[WARNING] 未找到Chrome可执行文件，将使用默认浏览器")
+            # 使用webbrowser模块打开
+            webbrowser.open(search_url)
+            # 构造一个基本结果
+            page_content = {
+                "count": 1,
+                "links": [{
+                    "index": 1,
+                    "url": search_url,
+                    "title": f"搜索: {keywords}"
+                }]
+            }
+            return 1
+            
+        logger.debug(f"[DEBUG] 找到Chrome路径: {chrome_path}")
         
-        # 尝试使用系统Chrome
-        try:
-            logger.debug("[DEBUG] 尝试使用channel='chrome'启动浏览器")
-            browser = await playwright.chromium.launch(
-                headless=False,
-                channel="chrome"
-            )
-        except Exception as e:
-            logger.debug(f"[DEBUG] channel='chrome'方式失败: {str(e)}")
-            logger.debug("[DEBUG] 尝试使用executable_path启动浏览器")
-            # 如果失败，尝试使用executable_path指定Chrome路径
-            browser = await playwright.chromium.launch(
-                headless=False, 
-                executable_path=chrome_path
+        # 检查playwright是否已经运行
+        if 'playwright_instance' not in globals() or playwright_instance is None:
+            logger.debug("[DEBUG] 初始化新的playwright实例")
+            # 第一次运行，初始化playwright
+            playwright_instance = await async_playwright().start()
+            
+            # 设置启动选项
+            browser_args = []
+            
+            # 使用系统已安装的Chrome
+            if chrome_path:
+                browser_args.extend([
+                    '--no-sandbox',  # 在某些环境中可能需要
+                    '--start-maximized'  # 最大化窗口
+                ])
+            
+            # 启动浏览器 - 尝试使用系统Chrome
+            try:
+                # 首先尝试使用chrome_path启动
+                logger.debug(f"[DEBUG] 尝试使用系统Chrome启动: {chrome_path}")
+                browser_instance = await playwright_instance.chromium.launch(
+                    headless=False,  # 显示浏览器界面
+                    executable_path=chrome_path,
+                    args=browser_args
+                )
+            except Exception as e:
+                logger.warning(f"[WARNING] 使用系统Chrome启动失败: {str(e)}，尝试使用默认浏览器")
+                # 如果失败，使用默认浏览器
+                browser_instance = await playwright_instance.chromium.launch(
+                    headless=False  # 显示浏览器界面
+                )
+            
+            # 创建上下文
+            context = await browser_instance.new_context(
+                viewport=None  # 不限制视窗大小，使用浏览器默认设置
             )
+            
+            # 创建新页面
+            page = await context.new_page()
+            
+            # 访问初始URL(知网首页)
+            logger.debug(f"[DEBUG] 导航到知网首页: {initial_url}")
+            await page.goto(initial_url)
+            logger.debug("[DEBUG] 已打开新的浏览器窗口并访问知网首页")
+        else:
+            logger.debug("[DEBUG] 在现有playwright实例中打开新标签页")
+            # playwright已经在运行，创建新标签页
+            page = await context.new_page()
+            # 访问初始URL(知网首页)
+            await page.goto(initial_url)
+            logger.debug("[DEBUG] 已在现有浏览器中打开新标签页并访问知网首页")
         
-        # 保存浏览器实例以防止被关闭
-        browser_instance = browser
-        
-        page = await browser.new_page()
-        
-        # 导航到知网搜索页面
-        await page.goto("https://kns.cnki.net/kns8s/search")
-        logger.debug("[DEBUG] 成功打开知网搜索页面")
+        # 等待页面加载完成
+        await page.wait_for_load_state('networkidle')
+        await asyncio.sleep(1)
         
-        # 等待页面加载
-        await page.wait_for_load_state("networkidle")
+        # 检查是否需要验证
+        await check_and_wait_for_verification(page)
         
-        # 查找并填写搜索框
+        # 尝试执行搜索操作
         try:
-            # 尝试定位搜索框
-            search_input = await page.query_selector('input.search-input')
+            # 方法1: 尝试在首页搜索框输入关键词
+            logger.debug("[DEBUG] 尝试在首页查找搜索框")
+            
+            # 查找搜索框
+            search_input_selectors = [
+                '#txt_search', 
+                'input[type="text"]', 
+                '.search-input',
+                '.input-box input',
+                'input.search-textbox',
+                'input[placeholder*="搜索"]'
+            ]
+            
+            search_input = None
+            for selector in search_input_selectors:
+                try:
+                    logger.debug(f"[DEBUG] 尝试查找搜索框选择器: {selector}")
+                    search_input = await page.query_selector(selector)
+                    if search_input:
+                        logger.debug(f"[DEBUG] 找到搜索框: {selector}")
+                        break
+                except Exception as e:
+                    logger.debug(f"[DEBUG] 查找选择器 {selector} 时出错: {str(e)}")
+            
             if search_input:
                 # 清空搜索框
                 await search_input.fill("")
                 # 输入关键词
-                await search_input.fill(keywords)
-                logger.debug(f"[DEBUG] 已在搜索框中输入: {keywords}")
+                await search_input.type(keywords, delay=100)  # 添加延迟模拟真实输入
+                logger.debug(f"[DEBUG] 已在搜索框中输入关键词: {keywords}")
                 
-                # 增加短暂等待以确保用户可以看到输入过程
-                await asyncio.sleep(1)
+                # 查找搜索按钮
+                search_button_selectors = [
+                    'button.search-btn', 
+                    'button.search',
+                    'button[type="submit"]',
+                    'input[type="submit"]',
+                    '.search-action',
+                    'a.search-btn'
+                ]
+                
+                search_button = None
+                for selector in search_button_selectors:
+                    try:
+                        logger.debug(f"[DEBUG] 尝试查找搜索按钮选择器: {selector}")
+                        search_button = await page.query_selector(selector)
+                        if search_button:
+                            logger.debug(f"[DEBUG] 找到搜索按钮: {selector}")
+                            break
+                    except Exception as e:
+                        logger.debug(f"[DEBUG] 查找选择器 {selector} 时出错: {str(e)}")
                 
-                # 查找并点击搜索按钮
-                search_button = await page.query_selector('.search-btn')
                 if search_button:
+                    # 点击搜索按钮
+                    logger.debug("[DEBUG] 点击搜索按钮")
                     await search_button.click()
-                    logger.debug("[DEBUG] 已点击搜索按钮")
-                    # 等待搜索结果加载
-                    await page.wait_for_load_state("networkidle")
                     
-                    # 点击操作1：点击下拉框的三角形
-                    try:
-                        # 等待一下，确保页面元素都加载完成
-                        await asyncio.sleep(2)
-                        
-                        # 尝试点击排序下拉框
-                        logger.debug("[DEBUG] 尝试点击排序下拉框")
-                        # 根据提供的HTML，尝试定位下拉框的三角形
-                        sort_dropdown = await page.query_selector('div[class="sort"][id="perPageDiv"]')
-                        if sort_dropdown:
-                            await sort_dropdown.click()
-                            logger.debug("[DEBUG] 成功点击排序下拉框")
-                            
-                            # 等待下拉菜单出现
-                            await asyncio.sleep(1)
-                            
-                            # 点击操作2：点击数字50选项
-                            logger.debug("[DEBUG] 尝试点击'50'选项")
-                            # 尝试定位"50"选项
-                            option_50 = await page.query_selector('li[data-val="50"]')
-                            if option_50:
-                                await option_50.click()
-                                logger.debug("[DEBUG] 成功点击'50'选项")
-                                await page.wait_for_load_state("networkidle")
-                                
-                                # 勾选来源类别中的CSSCI选项
-                                try:
-                                    # 等待一下确保页面完全加载
-                                    await asyncio.sleep(2)
-                                    
-                                    logger.debug("[DEBUG] 尝试勾选CSSCI选项")
-                                    
-                                    # 首先尝试找到来源类别区域
-                                    # 通常来源类别会有一个标题或者分组
-                                    source_category = await page.query_selector('div.group-item:has-text("来源类别")')
-                                    
-                                    if source_category:
-                                        logger.debug("[DEBUG] 找到来源类别区域")
-                                        
-                                        # 在来源类别区域内查找CSSCI选项
-                                        cssci_checkbox = await source_category.query_selector('input[type="checkbox"]:near(:text("CSSCI"))')
-                                        
-                                        if cssci_checkbox:
-                                            # 点击CSSCI复选框
-                                            await cssci_checkbox.click()
-                                            logger.debug("[DEBUG] 成功勾选CSSCI选项")
-                                            
-                                            # 等待页面刷新
-                                            await page.wait_for_load_state("networkidle")
-                                            
-                                            # 查找所有包含"article/abstract?v="字样的链接
-                                            links_count = await find_and_count_abstract_links(page)
-                                            
-                                            return links_count
-                                        else:
-                                            logger.debug("[DEBUG] 在来源类别区域未找到CSSCI选项")
-                                            
-                                            # 尝试另一种方式：直接在整个页面中查找CSSCI
-                                            cssci_text = await page.query_selector(':text("CSSCI")')
-                                            if cssci_text:
-                                                # 尝试点击文本附近的复选框
-                                                await cssci_text.click()
-                                                logger.debug("[DEBUG] 通过文本找到并点击了CSSCI")
-                                                await page.wait_for_load_state("networkidle")
-                                                
-                                                # 查找所有包含"article/abstract?v="字样的链接
-                                                links_count = await find_and_count_abstract_links(page)
-                                                
-                                                return links_count
-                                            else:
-                                                # 查找所有包含"article/abstract?v="字样的链接
-                                                links_count = await find_and_count_abstract_links(page)
-                                                return links_count
-                                    else:
-                                        logger.debug("[DEBUG] 未找到来源类别区域")
-                                        
-                                        # 尝试直接在页面中查找CSSCI文本
-                                        cssci_text = await page.query_selector(':text("CSSCI")')
-                                        if cssci_text:
-                                            # 尝试点击文本附近的复选框
-                                            await cssci_text.click()
-                                            logger.debug("[DEBUG] 直接找到并点击了CSSCI")
-                                            await page.wait_for_load_state("networkidle")
-                                            
-                                            # 查找所有包含"article/abstract?v="字样的链接
-                                            links_count = await find_and_count_abstract_links(page)
-                                            
-                                            return links_count
-                                        else:
-                                            # 查找所有包含"article/abstract?v="字样的链接
-                                            links_count = await find_and_count_abstract_links(page)
-                                            return links_count
-                                except Exception as e:
-                                    logger.debug(f"[DEBUG] 勾选CSSCI选项时出错: {str(e)}")
-                                    # 查找所有包含"article/abstract?v="字样的链接
-                                    links_count = await find_and_count_abstract_links(page)
-                                    return links_count
-                                
-                                # 查找所有包含"article/abstract?v="字样的链接
-                                links_count = await find_and_count_abstract_links(page)
-                                return links_count
-                            else:
-                                logger.debug("[DEBUG] 未找到'50'选项")
-                                page_content = {
-                                    "count": 0,
-                                    "links": [],
-                                    "error": "已搜索并点击下拉框，但未找到'50'选项"
-                                }
-                                return 0
-                        else:
-                            logger.debug("[DEBUG] 未找到排序下拉框")
-                            page_content = {
-                                "count": 0,
-                                "links": [],
-                                "error": "已搜索，但未找到排序下拉框"
-                            }
-                            return 0
-                    except Exception as e:
-                        logger.debug(f"[DEBUG] 点击下拉框或选项时出错: {str(e)}")
-                        page_content = {
-                            "count": 0,
-                            "links": [],
-                            "error": f"已搜索，但在点击下拉框或选项时出错: {str(e)}"
-                        }
-                        return 0
+                    # 等待搜索结果加载
+                    logger.debug("[DEBUG] 等待搜索结果加载")
+                    await page.wait_for_load_state('networkidle')
+                    await asyncio.sleep(2)
                 else:
-                    # 不关闭浏览器
-                    page_content = {
-                        "count": 0,
-                        "links": [],
-                        "error": f"已填写搜索关键词: {keywords}，但未找到搜索按钮"
-                    }
-                    return 0
+                    # 如果找不到搜索按钮，尝试按回车
+                    logger.debug("[DEBUG] 未找到搜索按钮，尝试按回车键")
+                    await search_input.press("Enter")
+                    
+                    # 等待搜索结果加载
+                    logger.debug("[DEBUG] 等待搜索结果加载")
+                    await page.wait_for_load_state('networkidle')
+                    await asyncio.sleep(2)
             else:
-                # 不关闭浏览器
-                page_content = {
-                    "count": 0,
-                    "links": [],
-                    "error": f"未找到搜索框，无法搜索: {keywords}"
-                }
-                return 0
+                # 如果找不到搜索框，直接导航到搜索URL
+                logger.debug(f"[DEBUG] 未找到搜索框，直接导航到搜索URL: {search_url}")
+                await page.goto(search_url)
+                await page.wait_for_load_state('networkidle')
+                await asyncio.sleep(2)
         except Exception as e:
-            logger.debug(f"[DEBUG] 填写搜索框或点击搜索按钮时出错: {str(e)}")
-            # 不关闭浏览器
+            logger.debug(f"[DEBUG] 执行搜索操作时出错: {str(e)}")
+            logger.debug(traceback.format_exc())
+            
+            # 如果交互失败，直接导航到搜索URL
+            logger.debug(f"[DEBUG] 导航到搜索URL: {search_url}")
+            await page.goto(search_url)
+            await page.wait_for_load_state('networkidle')
+            await asyncio.sleep(2)
+        
+        # 在搜索结果页面再次检查是否需要验证
+        await check_and_wait_for_verification(page)
+        
+        # 查找并计数链接
+        links_count = await find_and_count_abstract_links(page)
+        
+        # 添加等待时间让用户可以查看结果
+        await asyncio.sleep(5)
+        
+        logger.debug(f"[DEBUG] 搜索完成，找到 {links_count} 个链接")
+        
+        # 如果找不到链接，使用基本信息构造结果
+        if links_count == 0:
+            # 获取当前URL
+            current_url = await page.url()
+            page_content = {
+                "count": 1,
+                "links": [{
+                    "index": 1,
+                    "url": current_url,
+                    "title": f"搜索: {keywords}"
+                }]
+            }
+        
+        return links_count
+    except Exception as e:
+        error_msg = str(e)
+        logger.debug(f"[DEBUG] 搜索错误: {error_msg}")
+        logger.debug(traceback.format_exc())
+            
+        # 尝试直接使用webbrowser打开
+        try:
+            logger.debug("[DEBUG] 尝试使用webbrowser打开URL")
+            webbrowser.open(search_url)
+            
+            # 构造一个基本结果
+            page_content = {
+                "count": 1,
+                "links": [{
+                    "index": 1,
+                    "url": search_url,
+                    "title": f"搜索: {keywords}"
+                }]
+            }
+            return 1
+        except Exception as e2:
+            logger.debug(f"[DEBUG] 使用webbrowser打开URL失败: {str(e2)}")
+            
             page_content = {
                 "count": 0,
                 "links": [],
-                "error": f"自动搜索过程中出错: {str(e)}"
+                "error": f"搜索过程中出错: {error_msg}"
             }
             return 0
-    except Exception as e:
-        error_msg = str(e)
-        logger.debug(f"[DEBUG] Playwright错误: {error_msg}")
+
+async def check_and_wait_for_verification(page):
+    """检查页面是否需要验证，如果需要则等待用户手动验证"""
+    # 验证页面可能包含的特征
+    verification_indicators = [
+        '验证码',
+        '人机验证',
+        'captcha',
+        'verify',
+        '安全验证',
+        '滑动验证',
+        '拖动滑块',
+        '请完成验证',
+        '拼图验证'
+    ]
+    
+    try:
+        # 获取页面内容
+        page_text = await page.content()
         
-        # 如果是找不到Chrome的错误，提供更明确的指导
-        if "Executable doesn't exist" in error_msg and "ms-playwright" in error_msg:
-            error_message = f"需要安装Playwright的浏览器: playwright install\n如果您想使用系统Chrome，请重新启动服务器。\n\n{error_msg}"
-        else:
-            error_message = f"使用Playwright启动Chrome失败: {error_msg}"
+        # 检查是否包含验证指示词
+        needs_verification = any(indicator in page_text for indicator in verification_indicators)
+        
+        # 尝试查找常见的验证元素
+        verification_selectors = [
+            '.verify-wrap', 
+            '.captcha',
+            '.verification',
+            '#captcha',
+            '.slidecode',
+            '.verify-box',
+            '.verify-img-panel',
+            'iframe[src*="captcha"]',
+            'iframe[src*="verify"]'
+        ]
+        
+        for selector in verification_selectors:
+            try:
+                verify_elem = await page.query_selector(selector)
+                if verify_elem:
+                    needs_verification = True
+                    logger.info(f"[INFO] 检测到验证元素: {selector}")
+                    break
+            except:
+                pass
+        
+        if needs_verification:
+            logger.info("[INFO] 检测到验证页面，等待用户手动验证...")
+            print("\n*** 请注意 ***")
+            print("检测到需要验证码验证，请在浏览器中完成验证...")
+            print("验证完成后，程序将自动继续\n")
             
-        page_content = {
-            "count": 0,
-            "links": [],
-            "error": error_message
-        }
-        return 0
+            # 等待用户完成验证，验证页面可能有不同的特征表明验证完成
+            # 例如，特定元素消失或页面URL改变
+            max_wait_time = 120  # 最长等待2分钟
+            start_time = time.time()
+            current_url = await page.url()
+            
+            while time.time() - start_time < max_wait_time:
+                # 每隔一秒检查一次
+                await asyncio.sleep(1)
+                
+                # 检查URL是否改变（可能表示验证成功）
+                new_url = await page.url()
+                if new_url != current_url:
+                    logger.info("[INFO] 检测到URL变化，验证可能已完成")
+                    break
+                
+                # 再次检查验证元素是否消失
+                verification_still_present = False
+                for selector in verification_selectors:
+                    try:
+                        verify_elem = await page.query_selector(selector)
+                        if verify_elem:
+                            verification_still_present = True
+                            break
+                    except:
+                        pass
+                
+                if not verification_still_present:
+                    logger.info("[INFO] 验证元素已消失，验证可能已完成")
+                    break
+                
+                # 检查页面内容是否不再包含验证指示词
+                page_text = await page.content()
+                if not any(indicator in page_text for indicator in verification_indicators):
+                    logger.info("[INFO] 验证指示词已消失，验证可能已完成")
+                    break
+            
+            # 等待页面稳定
+            await page.wait_for_load_state('networkidle')
+            await asyncio.sleep(2)
+            
+            logger.info("[INFO] 继续执行，可能已完成验证")
+            print("继续执行操作...\n")
+        else:
+            logger.debug("[DEBUG] 未检测到验证页面")
+    
+    except Exception as e:
+        logger.error(f"[ERROR] 检查验证页面时出错: {str(e)}")
+        logger.error(traceback.format_exc())
 
 def search_with_direct_chrome(keywords):
     """直接使用Chrome搜索，不使用playwright"""
@@ -355,25 +512,26 @@ def search_with_direct_chrome(keywords):
         url = f"https://kns.cnki.net/kns8s/search?q={quote(keywords)}"
         logger.debug(f"[DEBUG] 打开URL: {url}")
         
+        # 使用open_chrome函数打开URL
         result = open_chrome(url)
         
-        if isinstance(result, str) and "打开Chrome" in result:
-            logger.debug(f"[DEBUG] 直接打开Chrome结果: {result}")
-            
-            page_content = {
-                "count": 0,
-                "links": [],
-                "error": f"直接打开Chrome搜索: {result}"
-            }
-            
-        else:
-            logger.debug("[DEBUG] 直接打开Chrome成功")
+        if isinstance(result, str) and "错误" in result:
+            logger.debug(f"[DEBUG] 打开Chrome失败: {result}")
             
             page_content = {
                 "count": 0,
                 "links": [],
-                "message": "已打开Chrome并搜索关键词，但无法自动获取链接。请安装playwright以获取完整功能。"
+                "error": f"打开Chrome搜索失败: {result}"
             }
+            return page_content
+        
+        logger.debug("[DEBUG] 已尝试在已有Chrome窗口中打开新标签页")
+        
+        page_content = {
+            "count": 0,
+            "links": [],
+            "message": "已打开Chrome并搜索关键词，但无法自动获取链接。请安装playwright以获取完整功能。"
+        }
         
         return page_content
     except Exception as e:
@@ -600,10 +758,10 @@ async def handle_list_tools() -> list[types.Tool]:
     tools = []
     
     # 只添加搜索并提取的组合工具
-    if extractor is not None and PLAYWRIGHT_AVAILABLE:
+    if PLAYWRIGHT_AVAILABLE:
         tools.append(
             types.Tool(
-                name="mcp_cnks_search_and_extract",
+                name="search_and_extract",
                 description="搜索知网关键词并提取所有论文的详细内容",
                 inputSchema={
                     "type": "object",
@@ -624,7 +782,7 @@ async def handle_call_tool(
     """处理工具执行请求"""
     global current_url, page_content
     
-    if name == "mcp_cnks_search_and_extract" and extractor is not None and PLAYWRIGHT_AVAILABLE:
+    if name == "search_and_extract" and PLAYWRIGHT_AVAILABLE:
         if not arguments:
             raise ValueError("缺少参数")
         
@@ -635,39 +793,95 @@ async def handle_call_tool(
         try:
             # 第一步：执行搜索
             logger.info(f"开始执行搜索并提取：关键词 '{keywords}'")
-            links_count = await search_with_playwright(keywords)
-            current_url = "https://kns.cnki.net/kns8s/search"
+            
+            # 构建URL
+            url = f"https://kns.cnki.net/kns8s/search?q={quote(keywords)}"
+            current_url = url
+            logger.debug(f"[DEBUG] 搜索URL: {url}")
+            
+            # 如果playwright可用，使用playwright搜索
+            if PLAYWRIGHT_AVAILABLE:
+                logger.debug("[DEBUG] 使用playwright搜索")
+                links_count = await search_with_playwright(keywords)
+            else:
+                # 否则直接用open_chrome打开URL
+                logger.debug("[DEBUG] 直接使用open_chrome打开URL")
+                result = open_chrome(url)
+                
+                if isinstance(result, str):
+                    # 如果是错误信息，返回错误
+                    return [
+                        types.TextContent(
+                            type="text",
+                            text=json.dumps({
+                                "error": f"打开Chrome失败: {result}",
+                                "keywords": keywords,
+                                "count": 0,
+                                "results": []
+                            })
+                        )
+                    ]
+                else:
+                    # 成功打开但无法获取链接
+                    return [
+                        types.TextContent(
+                            type="text",
+                            text=json.dumps({
+                                "keywords": keywords,
+                                "count": 0,
+                                "message": "已直接在Chrome中打开搜索页面，但无法自动获取搜索结果。请安装playwright以获取完整功能。",
+                                "results": []
+                            })
+                        )
+                    ]
             
             # 检查搜索结果
             if not isinstance(page_content, dict) or "links" not in page_content or not page_content["links"]:
+                # 如果没有找到链接，至少返回搜索页面作为结果
+                logger.debug("[DEBUG] 搜索未返回有效链接，返回搜索页面作为结果")
                 return [
                     types.TextContent(
                         type="text",
-                        text={
-                            "error": "搜索未返回有效链接",
-                            "count": 0,
-                            "results": []
-                        }
+                        text=json.dumps({
+                            "keywords": keywords,
+                            "count": 1,
+                            "results": [{
+                                "title": f"搜索结果: {keywords}",
+                                "authors": [],
+                                "abstract": "请在浏览器中查看搜索结果",
+                                "keywords": [],
+                                "cite_format": "",
+                                "url": url
+                            }]
+                        })
                     )
                 ]
             
             # 提取链接
             urls = [link["url"] for link in page_content["links"] if "url" in link]
             if not urls:
+                logger.debug("[DEBUG] 没有找到有效链接，返回搜索页面")
                 return [
                     types.TextContent(
                         type="text",
-                        text={
-                            "error": "未找到有效链接",
-                            "count": 0,
-                            "results": []
-                        }
+                        text=json.dumps({
+                            "keywords": keywords,
+                            "count": 1,
+                            "results": [{
+                                "title": f"搜索结果: {keywords}",
+                                "authors": [],
+                                "abstract": "请在浏览器中查看搜索结果",
+                                "keywords": [],
+                                "cite_format": "",
+                                "url": url
+                            }]
+                        })
                     )
                 ]
             
             # 第二步：执行提取
             logger.info(f"搜索成功，找到 {len(urls)} 个链接，开始提取内容")
-            results = await extractor.batch_extract_contents(urls)
+            results = await batch_extract_contents(urls)
             
             # 包装结果
             result_json = {
@@ -681,7 +895,7 @@ async def handle_call_tool(
             return [
                 types.TextContent(
                     type="text",
-                    text=result_json
+                    text=json.dumps(result_json)
                 )
             ]
         except Exception as e:
@@ -690,12 +904,12 @@ async def handle_call_tool(
             return [
                 types.TextContent(
                     type="text",
-                    text={
+                    text=json.dumps({
                         "error": f"搜索并提取内容时出错: {str(e)}",
                         "keywords": keywords,
                         "count": 0,
                         "results": []
-                    }
+                    })
                 )
             ]
     
@@ -703,69 +917,853 @@ async def handle_call_tool(
         raise ValueError(f"未知工具: {name}")
 
 async def find_and_count_abstract_links(page):
-    """查找并统计包含article/abstract?v=的链接"""
+    """查找并统计知网搜索结果页面中的论文链接"""
     global page_content
     
     try:
-        logger.debug("[DEBUG] 开始查找所有包含article/abstract?v=的链接")
+        logger.debug("[DEBUG] 开始查找知网搜索结果中的论文链接")
         
         # 等待确保页面完全加载
-        await asyncio.sleep(2)
+        await asyncio.sleep(3)
         
-        # 查找所有链接
-        all_links = await page.query_selector_all('a[href*="article/abstract?v="]')
-        links_count = len(all_links)
-        
-        logger.debug(f"[DEBUG] 找到{links_count}条包含article/abstract?v=的链接")
+        # 首先尝试设置每页显示50条记录
+        try:
+            logger.debug("[DEBUG] 尝试设置每页显示50条记录")
+            
+            # 使用更直接的JavaScript方法点击50条
+            set_page_size_result = await page.evaluate("""() => {
+                try {
+                    // 更精确地找到下拉框并点击
+                    const dropdowns = document.querySelectorAll('#perPageDiv, .perpage-content, .page-count, div[class*="perpage"]');
+                    if (dropdowns && dropdowns.length > 0) {
+                        // 记录找到的下拉框
+                        console.log('找到下拉框元素:', dropdowns[0]);
+                        // 点击下拉框
+                        dropdowns[0].click();
+                        console.log('已点击下拉框');
+                        
+                        // 直接等待而不使用setTimeout，确保下拉菜单显示
+                        return new Promise(resolve => {
+                            setTimeout(() => {
+                                // 查找并点击50选项
+                                const options = document.querySelectorAll('a[data-v="50"], a[href*="50"], li[data-val="50"]');
+                                console.log('找到的50选项数量:', options.length);
+                                
+                                for (let option of options) {
+                                    if (option.textContent.includes('50')) {
+                                        option.click();
+                                        console.log('已点击50选项:', option);
+                                        resolve("点击了50选项：" + option.textContent);
+                                        return;
+                                    }
+                                }
+                                
+                                // 如果没有找到特定的50选项，尝试点击最后一个选项（通常是最大数值）
+                                const allOptions = document.querySelectorAll('.perpage-content a, .sort-list li');
+                                if (allOptions && allOptions.length > 0) {
+                                    const lastOption = allOptions[allOptions.length - 1];
+                                    lastOption.click();
+                                    console.log('点击了最后一个选项:', lastOption.textContent);
+                                    resolve("点击了最后一个选项：" + lastOption.textContent);
+                                    return;
+                                }
+                                
+                                resolve("未找到50条/页选项");
+                            }, 1000); // 等待一秒确保下拉菜单显示
+                        });
+                    }
+                    
+                    // 尝试另一种方式 - 直接点击带有"50"的链接
+                    const directLinks = document.querySelectorAll('a:not([style*="display:none"]):not([style*="display: none"])');
+                    for (let link of directLinks) {
+                        if (link.textContent.trim() === '50' || 
+                            link.textContent.includes('50条') || 
+                            link.textContent.includes('50 条')) {
+                            link.click();
+                            return "直接点击了50条链接: " + link.textContent;
+                        }
+                    }
+                    
+                    return "未找到任何可点击的50条/页选项";
+                } catch (e) {
+                    return "设置每页显示50条记录时出错: " + e.toString();
+                }
+            }""")
+            
+            logger.debug(f"[DEBUG] 设置每页显示50条记录结果: {set_page_size_result}")
+            
+            # 等待页面刷新
+            await page.wait_for_load_state('networkidle')
+            await asyncio.sleep(2)
+            
+            # 检查是否有来源类别选项，并尝试勾选CSSCI
+            await check_and_select_cssci(page)
+            
+        except Exception as e:
+            logger.debug(f"[DEBUG] 设置每页显示50条记录时出错: {str(e)}")
+            logger.debug(traceback.format_exc())
         
-        # 提取并记录每个链接的URL和文本
-        links_info = []
+        # 尝试等待搜索结果加载
+        try:
+            await page.wait_for_selector('.result-table-list', timeout=5000)
+            logger.debug("[DEBUG] 已找到搜索结果容器")
+        except Exception as e:
+            logger.debug(f"[DEBUG] 等待搜索结果容器超时: {str(e)}")
         
-        for i, link in enumerate(all_links):
-            href = await link.get_attribute('href')
+        # 优先查找带有article/abstract?v的链接
+        try:
+            logger.debug("[DEBUG] 尝试查找包含 article/abstract?v 的链接")
+            
+            abstract_links = await page.evaluate("""() => {
+                const links = [];
+                // 严格查找包含article/abstract?v的链接
+                const abstractLinks = document.querySelectorAll('a[href*="article/abstract?v="]');
+                
+                console.log('找到包含article/abstract?v的链接数量:', abstractLinks.length);
+                
+                for (let i = 0; i < abstractLinks.length; i++) {
+                    const link = abstractLinks[i];
+                    const href = link.href;
+                    const text = link.textContent.trim();
+                    
+                    // 确保链接有效且包含必要的字段
+                    if (href && href.includes('article/abstract?v=') && text) {
+                        links.push({
+                            index: links.length + 1,
+                            href: href,
+                            text: text
+                        });
+                    }
+                }
+                
+                return links;
+            }""")
             
-            links_info.append({
-                'index': i + 1,
-                'href': href
-            })
+            logger.debug(f"[DEBUG] 找到 {len(abstract_links)} 个包含article/abstract?v的链接")
             
-            logger.debug(f"[DEBUG] 链接 {i+1}: {href}")
+            if abstract_links and len(abstract_links) > 0:
+                # 找到有效的摘要链接
+                links_info = abstract_links
+                links_count = len(abstract_links)
+            else:
+                # 没有找到摘要链接，尝试备用方法
+                logger.debug("[DEBUG] 未找到包含article/abstract?v的链接，尝试备用方法")
+                
+                # 尝试查找可能的论文链接
+                backup_links = await page.evaluate("""() => {
+                    const links = [];
+                    // 查找可能是论文链接的a标签
+                    const allLinks = document.querySelectorAll('a.fz14, a[href*="/kcms"], .result-table-list a');
+                    
+                    for (let i = 0; i < allLinks.length; i++) {
+                        const link = allLinks[i];
+                        const href = link.href;
+                        const text = link.textContent.trim();
+                        
+                        if (href && text && !links.some(l => l.href === href)) {
+                            links.push({
+                                index: links.length + 1,
+                                href: href,
+                                text: text
+                            });
+                        }
+                    }
+                    
+                    return links;
+                }""")
+                
+                if backup_links and len(backup_links) > 0:
+                    logger.debug(f"[DEBUG] 使用备用方法找到 {len(backup_links)} 个可能的论文链接")
+                    links_info = backup_links
+                    links_count = len(backup_links)
+                else:
+                    # 回退到常规方法
+                    links_info = []
+                    links_count = 0
+                    
+                    # 尝试多种可能的选择器
+                    selectors = [
+                        'a[href*="article/abstract?v="]',  # 优先查找摘要链接
+                        'a[href*="/kcms"]',                # 知网文献链接
+                        '.fz14',                           # 标题样式类
+                        'a.pc-link',                       # 搜索结果链接
+                        '.c_font a',                       # 内容字体下的链接
+                        '.result-table-list a',            # 结果表下的链接
+                        'table tr td a'                    # 表格中的链接
+                    ]
+                    
+                    for selector in selectors:
+                        try:
+                            all_links = await page.query_selector_all(selector)
+                            logger.debug(f"[DEBUG] 使用选择器 {selector} 找到 {len(all_links)} 个链接")
+                            
+                            for i, link in enumerate(all_links):
+                                try:
+                                    href = await link.get_attribute('href')
+                                    text = await link.text_content()
+                                    
+                                    # 确保链接包含论文相关URL，如果没有指定URL则使用当前页面URL
+                                    if not href:
+                                        continue
+                                    
+                                    # 处理相对URL
+                                    if href.startswith('/'):
+                                        href = f"https://kns.cnki.net{href}"
+                                    elif not href.startswith('http'):
+                                        href = f"https://kns.cnki.net/{href}"
+                                        
+                                    # 防止重复添加同一链接
+                                    if any(link_info['href'] == href for link_info in links_info):
+                                        continue
+                                        
+                                    links_info.append({
+                                        'index': len(links_info) + 1,
+                                        'href': href,
+                                        'text': text.strip() if text else ""
+                                    })
+                                    
+                                    logger.debug(f"[DEBUG] 链接 {len(links_info)}: {href}")
+                                except Exception as e:
+                                    logger.debug(f"[DEBUG] 处理链接时出错: {str(e)}")
+                        except Exception as e:
+                            logger.debug(f"[DEBUG] 使用选择器 {selector} 查找链接时出错: {str(e)}")
+        except Exception as e:
+            logger.debug(f"[DEBUG] 查找链接时出错: {str(e)}")
+            logger.debug(traceback.format_exc())
+            links_info = []
+            links_count = 0
         
-        # 判断数量是否符合预期(50条)
-        if links_count == 50:
-            logger.debug("[DEBUG] 链接数量正好是50条，符合预期")
-        elif links_count < 50:
-            logger.debug(f"[DEBUG] 链接数量为{links_count}条，少于预期的50条")
-        else:
-            logger.debug(f"[DEBUG] 链接数量为{links_count}条，多于预期的50条")
+        # 过滤链接，只保留包含article/abstract?v的链接
+        filtered_links = []
+        for link in links_info:
+            href = link['href']
+            if 'article/abstract?v=' in href:
+                filtered_links.append(link)
+                logger.debug(f"[DEBUG] 保留包含article/abstract?v的链接: {href}")
+        
+        # 如果过滤后没有链接，可能是知网搜索结果的格式变化，使用原始链接
+        if not filtered_links:
+            logger.debug("[DEBUG] 过滤后没有包含article/abstract?v的链接，使用原始链接")
+            filtered_links = links_info
+        
+        # 最终链接数量
+        links_count = len(filtered_links)
+        logger.debug(f"[DEBUG] 最终过滤后找到 {links_count} 个链接")
+        
+        # 如果没有找到链接，不再进行截图
+        if links_count == 0:
+            logger.debug("[DEBUG] 未找到链接")
         
         # 存储结果 - 使用字典结构而不是纯文本
         page_content = {
             "count": links_count,
-            "links": [{"index": link['index'], "url": link['href']} for link in links_info]
+            "links": [{"index": link['index'], "url": link['href'], "title": link['text']} for link in filtered_links]
         }
         
         return links_count
     except Exception as e:
         logger.debug(f"[DEBUG] 查找链接时出错: {str(e)}")
-        return 0
+        logger.debug(traceback.format_exc())
+        
+        # 发生错误时，尝试获取当前页面URL
+        try:
+            current_url = await page.url()
+            logger.debug(f"[DEBUG] 当前页面URL: {current_url}")
+            
+            # 至少返回当前页面作为链接
+            page_content = {
+                "count": 1,
+                "links": [{"index": 1, "url": current_url, "title": "当前页面"}]
+            }
+            return 1
+        except:
+            page_content = {
+                "count": 0,
+                "links": []
+            }
+            return 0
+
+async def check_and_select_cssci(page):
+    """检查页面是否有来源类别选项，并尝试勾选CSSCI"""
+    try:
+        logger.debug("[DEBUG] 尝试查找来源类别并勾选CSSCI")
+        
+        # 使用JavaScript直接操作DOM
+        cssci_result = await page.evaluate("""() => {
+            try {
+                // 查找包含"来源类别"的区域
+                const categoryContainer = Array.from(document.querySelectorAll('div')).find(div => 
+                    div.textContent.includes('来源类别')
+                );
+                
+                if (categoryContainer) {
+                    // 在来源类别容器中查找CSSCI复选框
+                    const checkboxes = categoryContainer.querySelectorAll('input[type="checkbox"]');
+                    for (let checkbox of checkboxes) {
+                        // 查找CSSCI相关的复选框
+                        const parentText = checkbox.parentElement.textContent;
+                        if (parentText.includes('CSSCI') || 
+                            checkbox.value.includes('CSSCI') || 
+                            checkbox.id.includes('cssci')) {
+                            
+                            // 勾选复选框
+                            if (!checkbox.checked) {
+                                checkbox.click();
+                                return "已勾选CSSCI复选框";
+                            } else {
+                                return "CSSCI复选框已经被勾选";
+                            }
+                        }
+                    }
+                    
+                    // 如果没有找到复选框但找到了CSSCI的标签
+                    const cssciLabels = categoryContainer.querySelectorAll('label, span');
+                    for (let label of cssciLabels) {
+                        if (label.textContent.includes('CSSCI')) {
+                            label.click();
+                            return "已点击CSSCI标签";
+                        }
+                    }
+                    
+                    return "在来源类别区域未找到CSSCI选项";
+                }
+                
+                return "未找到来源类别区域";
+            } catch (e) {
+                return "勾选CSSCI时出错: " + e.toString();
+            }
+        }""")
+        
+        logger.debug(f"[DEBUG] CSSCI勾选结果: {cssci_result}")
+        
+        # 等待页面刷新
+        await page.wait_for_load_state('networkidle')
+        await asyncio.sleep(2)
+            
+    except Exception as e:
+        logger.debug(f"[DEBUG] 勾选CSSCI时出错: {str(e)}")
+        logger.debug(traceback.format_exc())
+
+async def extract_content_from_url(url: str, page = None) -> CNKIContent:
+    """从CNKI页面提取论文内容"""
+    global playwright_instance, browser_instance, context
+    
+    if not url.startswith('http'):
+        # 处理相对URL
+        if url.startswith('/'):
+            url = f"https://kns.cnki.net{url}"
+        else:
+            url = f"https://kns.cnki.net/{url}"
+    
+    # 创建基本内容对象
+    content = CNKIContent(url=url)
+    
+    try:
+        logger.info(f"开始从URL提取内容: {url}")
+        
+        # 如果没有提供page参数，检查playwright是否已初始化
+        should_close_page = False
+        if page is None:
+            if playwright_instance is None or browser_instance is None or context is None:
+                # 如果playwright未初始化，使用webbrowser打开URL
+                logger.info(f"Playwright未初始化，使用webbrowser打开URL: {url}")
+                webbrowser.open(url)
+                
+                # 设置基本信息
+                content.title = "请在浏览器中手动获取内容"
+                content.abstract = "系统已打开链接，请在浏览器中查看完整内容"
+                return content
+            else:
+                # 使用现有的playwright实例创建新页面
+                logger.debug("[DEBUG] 使用现有的playwright实例创建新页面")
+                page = await context.new_page()
+                should_close_page = True  # 后续需要关闭此页面
+        
+        # 访问URL
+        logger.debug(f"[DEBUG] 导航到URL: {url}")
+        
+        try:
+            await page.goto(url, wait_until='networkidle', timeout=30000)
+        except Exception as e:
+            logger.warning(f"导航超时，继续尝试提取: {str(e)}")
+            
+        # 等待页面加载
+        await asyncio.sleep(2)
+        
+        # 检查是否需要验证
+        await check_and_wait_for_verification(page)
+        
+        # 尝试使用JavaScript提取所有内容
+        try:
+            logger.debug("[DEBUG] 尝试使用JavaScript提取内容")
+            
+            content_result = await page.evaluate("""() => {
+                try {
+                    // 提取标题
+                    const getTitle = () => {
+                        const selectors = ['h1.title', '.wx-tit h1', '.title', 'h1', '.article-title', 'div.brief h2', '.wxTitle', 'span.title'];
+                        for (const selector of selectors) {
+                            const element = document.querySelector(selector);
+                            if (element) {
+                                const text = element.textContent.trim();
+                                if (!text.includes('系统检测')) {
+                                    return text;
+                                }
+                            }
+                        }
+                        return "";
+                    };
+                    
+                    // 提取作者
+                    const getAuthors = () => {
+                        const selectors = ['.wx-tit .author', '.author', '.writers', '.authorinfo', 'div.brief p:first-child', 'span.author'];
+                        for (const selector of selectors) {
+                            const element = document.querySelector(selector);
+                            if (element) {
+                                const text = element.textContent.trim();
+                                return text.split(/[,，;；、\\s]+/).filter(a => a.trim());
+                            }
+                        }
+                        return [];
+                    };
+                    
+                    // 提取摘要
+                    const getAbstract = () => {
+                        const selectors = ['#ChDivSummary', '.abstract', '.summary', '.Abstract', 'div.brief div.abstract', 'div.wxInfo span.abstract', 'div.wxInfo', 'span.abstract'];
+                        for (const selector of selectors) {
+                            const element = document.querySelector(selector);
+                            if (element) {
+                                let text = element.textContent.trim();
+                                // 移除可能的"摘要:"前缀
+                                text = text.replace(/^摘要[：:]/g, '').trim();
+                                return text;
+                            }
+                        }
+                        
+                        // 查找含有"摘要"的段落
+                        const paragraphs = document.querySelectorAll('p');
+                        for (const p of paragraphs) {
+                            if (p.textContent.includes('摘要')) {
+                                let text = p.textContent.trim();
+                                text = text.replace(/^摘要[：:]/g, '').trim();
+                                return text;
+                            }
+                        }
+                        
+                        return "";
+                    };
+                    
+                    // 提取关键词
+                    const getKeywords = () => {
+                        const selectors = ['.wx-tit-keys', '.keywords', '.Keyword', 'div.wxInfo span.keywords', 'span.keywords', 'div.brief span.keywords', 'p.keywords'];
+                        for (const selector of selectors) {
+                            const element = document.querySelector(selector);
+                            if (element) {
+                                let text = element.textContent.trim();
+                                // 移除"关键词:"前缀
+                                text = text.replace(/^关键词[：:]/g, '').trim();
+                                return text.split(/[;；,，、\\s]+/).filter(k => k.trim());
+                            }
+                        }
+                        
+                        // 查找含有"关键词"的段落
+                        const paragraphs = document.querySelectorAll('p');
+                        for (const p of paragraphs) {
+                            if (p.textContent.includes('关键词')) {
+                                let text = p.textContent.trim();
+                                const keywordText = text.split(/关键词[：:]/)[1];
+                                if (keywordText) {
+                                    return keywordText.split(/[;；,，、\\s]+/).filter(k => k.trim());
+                                }
+                            }
+                        }
+                        
+                        return [];
+                    };
+                    
+                    // 尝试获取引用格式
+                    let citeFormat = "";
+                    const getCiteFormat = () => {
+                        // 首先检查是否有引用按钮
+                        const citeButton = document.querySelector('button:has-text("引用"), [class*="cite"], [class*="quote"]');
+                        if (citeButton) {
+                            // 如果有引用按钮，暂不点击，防止页面跳转
+                            return null;
+                        }
+                        
+                        // 尝试直接获取引用区域
+                        const selectors = ['.quote-info', '.citation', 'div.cite', 'div.quoted', 'div.wxInfo div.quoted', '.refer-info'];
+                        for (const selector of selectors) {
+                            const element = document.querySelector(selector);
+                            if (element) {
+                                return element.textContent.trim();
+                            }
+                        }
+                        
+                        return "";
+                    };
+                    
+                    // 收集结果
+                    return {
+                        title: getTitle(),
+                        authors: getAuthors(),
+                        abstract: getAbstract(),
+                        keywords: getKeywords(),
+                        cite_format: getCiteFormat()
+                    };
+                } catch (e) {
+                    return {
+                        error: "提取内容时出错: " + e.toString(),
+                        title: "",
+                        authors: [],
+                        abstract: "",
+                        keywords: [],
+                        cite_format: ""
+                    };
+                }
+            }""")
+            
+            # 更新内容对象
+            if content_result:
+                if "error" in content_result and content_result["error"]:
+                    logger.warning(f"[WARNING] JavaScript提取内容时出错: {content_result['error']}")
+                else:
+                    logger.debug("[DEBUG] JavaScript提取内容成功")
+                    
+                    # 更新标题
+                    if content_result.get("title"):
+                        content.title = content_result["title"]
+                        logger.debug(f"[DEBUG] 提取到标题: {content.title}")
+                    
+                    # 更新作者
+                    if content_result.get("authors"):
+                        content.authors = content_result["authors"]
+                        logger.debug(f"[DEBUG] 提取到作者: {content.authors}")
+                    
+                    # 更新摘要
+                    if content_result.get("abstract"):
+                        content.abstract = content_result["abstract"]
+                        logger.debug(f"[DEBUG] 提取到摘要: {content.abstract[:100]}...")
+                    
+                    # 更新关键词
+                    if content_result.get("keywords"):
+                        content.keywords = content_result["keywords"]
+                        logger.debug(f"[DEBUG] 提取到关键词: {content.keywords}")
+                    
+                    # 更新引用格式
+                    if content_result.get("cite_format") != None:
+                        if content_result["cite_format"]:
+                            # 直接获取到引用格式
+                            content.cite_format = content_result["cite_format"]
+                            logger.debug(f"[DEBUG] 提取到引用格式: {content.cite_format[:100]}...")
+                        else:
+                            # 需要点击引用按钮
+                            logger.debug("[DEBUG] 尝试点击引用按钮获取引用格式")
+                            
+                            try:
+                                # 查找引用按钮
+                                cite_button = await page.query_selector('button:has-text("引用"), [class*="cite"], [class*="quote"]')
+                                if cite_button:
+                                    await cite_button.click()
+                                    await asyncio.sleep(1)  # 等待弹窗显示
+                                    
+                                    # 在弹窗中提取引用格式
+                                    cite_text = await page.evaluate("""() => {
+                                        const textarea = document.querySelector('.quote-r textarea.text, .quote-text, [class*="quote"] textarea');
+                                        if (textarea) {
+                                            return textarea.value.trim();
+                                        }
+                                        return "";
+                                    }""")
+                                    
+                                    if cite_text:
+                                        content.cite_format = cite_text
+                                        logger.debug(f"[DEBUG] 从弹窗提取到引用格式: {content.cite_format[:100]}...")
+                                    else:
+                                        logger.debug("[DEBUG] 未从弹窗找到引用格式")
+                                else:
+                                    logger.debug("[DEBUG] 未找到引用按钮")
+                            except Exception as e:
+                                logger.debug(f"[DEBUG] 点击引用按钮时出错: {str(e)}")
+            else:
+                logger.warning("[WARNING] JavaScript提取内容返回空结果")
+                
+        except Exception as e:
+            logger.debug(f"[DEBUG] 使用JavaScript提取内容时出错: {str(e)}")
+            logger.debug(traceback.format_exc())
+        
+        # 如果JavaScript提取失败，回退到原来的提取方法
+        if not content.title:
+            # 尝试提取论文标题
+            try:
+                title_selectors = [
+                    '.wx-tit h1', 
+                    '.article-title', 
+                    '.title', 
+                    'h1', 
+                    '.articleTitle',
+                    'div.brief h2',
+                    '.wxTitle',
+                    'span.title'
+                ]
+                
+                title_elem = None
+                for selector in title_selectors:
+                    title_elem = await page.query_selector(selector)
+                    if title_elem:
+                        logger.debug(f"[DEBUG] 找到标题元素: {selector}")
+                        break
+                        
+                if title_elem:
+                    content.title = await title_elem.text_content()
+                    content.title = content.title.strip()
+                    logger.debug(f"[DEBUG] 提取到标题: {content.title}")
+            except Exception as e:
+                logger.debug(f"[DEBUG] 提取标题时出错: {str(e)}")
+        
+        if not content.authors:
+            # 尝试提取作者信息
+            try:
+                author_selectors = [
+                    '.wx-tit .author', 
+                    '.author', 
+                    '.writers',
+                    '.authorinfo',
+                    'div.brief p:first-child',
+                    'span.author'
+                ]
+                
+                authors_elem = None
+                for selector in author_selectors:
+                    authors_elem = await page.query_selector(selector)
+                    if authors_elem:
+                        logger.debug(f"[DEBUG] 找到作者元素: {selector}")
+                        break
+                        
+                if authors_elem:
+                    authors_text = await authors_elem.text_content()
+                    # 分割作者文本
+                    authors = [a.strip() for a in re.split(r'[,，;；、\s]+', authors_text) if a.strip()]
+                    content.authors = authors
+                    logger.debug(f"[DEBUG] 提取到作者: {authors}")
+            except Exception as e:
+                logger.debug(f"[DEBUG] 提取作者时出错: {str(e)}")
+        
+        if not content.abstract:
+            # 尝试提取摘要
+            try:
+                abstract_selectors = [
+                    '#ChDivSummary', 
+                    '.abstract', 
+                    '.summary', 
+                    '.Abstract',
+                    'div.brief div.abstract',
+                    'div.wxInfo span.abstract',
+                    'div.wxInfo',
+                    'span.abstract'
+                ]
+                
+                abstract_elem = None
+                for selector in abstract_selectors:
+                    abstract_elem = await page.query_selector(selector)
+                    if abstract_elem:
+                        logger.debug(f"[DEBUG] 找到摘要元素: {selector}")
+                        break
+                        
+                if abstract_elem:
+                    content.abstract = await abstract_elem.text_content()
+                    content.abstract = content.abstract.strip()
+                    # 移除可能的"摘要:"前缀
+                    content.abstract = re.sub(r'^摘要[：:]\s*', '', content.abstract)
+                    logger.debug(f"[DEBUG] 提取到摘要: {content.abstract[:100]}...")
+            except Exception as e:
+                logger.debug(f"[DEBUG] 提取摘要时出错: {str(e)}")
+        
+        if not content.keywords:
+            # 尝试提取关键词
+            try:
+                keyword_selectors = [
+                    '.wx-tit-keys', 
+                    '.keywords', 
+                    '.Keyword',
+                    'div.wxInfo span.keywords',
+                    'span.keywords',
+                    'div.brief span.keywords',
+                    'p.keywords'
+                ]
+                
+                keywords_elem = None
+                for selector in keyword_selectors:
+                    keywords_elem = await page.query_selector(selector)
+                    if keywords_elem:
+                        logger.debug(f"[DEBUG] 找到关键词元素: {selector}")
+                        break
+                        
+                if keywords_elem:
+                    keywords_text = await keywords_elem.text_content()
+                    # 移除"关键词:"前缀
+                    keywords_text = re.sub(r'^关键词[：:]\s*', '', keywords_text)
+                    # 分割关键词
+                    keywords = [k.strip() for k in re.split(r'[;；,，、\s]+', keywords_text) if k.strip()]
+                    content.keywords = keywords
+                    logger.debug(f"[DEBUG] 提取到关键词: {keywords}")
+            except Exception as e:
+                logger.debug(f"[DEBUG] 提取关键词时出错: {str(e)}")
+        
+        if not content.cite_format:
+            # 尝试提取引用格式
+            try:
+                cite_selectors = [
+                    '.quote-info', 
+                    '.citation',
+                    'div.cite',
+                    'div.quoted',
+                    'div.wxInfo div.quoted',
+                    '.refer-info'
+                ]
+                
+                cite_elem = None
+                for selector in cite_selectors:
+                    cite_elem = await page.query_selector(selector)
+                    if cite_elem:
+                        logger.debug(f"[DEBUG] 找到引用格式元素: {selector}")
+                        break
+                        
+                if cite_elem:
+                    content.cite_format = await cite_elem.text_content()
+                    content.cite_format = content.cite_format.strip()
+                    logger.debug(f"[DEBUG] 提取到引用格式: {content.cite_format[:100]}...")
+                else:
+                    # 如果没有找到引用格式，尝试点击引用按钮
+                    cite_button = await page.query_selector('button:has-text("引用"), [class*="cite"], [class*="quote"]')
+                    if cite_button:
+                        await cite_button.click()
+                        await asyncio.sleep(1)  # 等待弹窗显示
+                        
+                        # 在弹窗中提取引用格式
+                        textarea = await page.query_selector('.quote-r textarea.text, .quote-text, [class*="quote"] textarea')
+                        if textarea:
+                            content.cite_format = await textarea.get_property('value')
+                            content.cite_format = content.cite_format.strip()
+                            logger.debug(f"[DEBUG] 从弹窗提取到引用格式: {content.cite_format[:100]}...")
+            except Exception as e:
+                logger.debug(f"[DEBUG] 提取引用格式时出错: {str(e)}")
+        
+        # 如果页面是自己创建的，需要关闭
+        if should_close_page:
+            await page.close()
+            
+        return content
+    except Exception as e:
+        logger.error(f"从URL提取内容时出错: {str(e)}")
+        logger.error(traceback.format_exc())
+        
+        # 确保如果页面是自己创建的，出错时也能关闭
+        if 'page' in locals() and page is not None and 'should_close_page' in locals() and should_close_page:
+            try:
+                await page.close()
+            except:
+                pass
+                
+        # 设置错误信息
+        content.title = f"提取失败: {str(e)}"
+        content.abstract = f"从URL提取内容时出错: {str(e)}"
+        return content
+
+async def batch_extract_contents(urls: List[str]) -> List[Dict]:
+    """批量处理多个URL，提取内容并返回JSON格式"""
+    results = []
+    max_urls = min(50, len(urls))  # 限制最多处理50个URL
+    
+    logger.info(f"开始批量提取内容，共 {max_urls} 个URL")
+    
+    try:
+        # 检查是否已初始化playwright
+        global playwright_instance, browser_instance, context
+        
+        if playwright_instance is None or browser_instance is None or context is None:
+            logger.info("Playwright未初始化，创建新实例")
+            playwright_instance = await async_playwright().start()
+            browser_instance = await playwright_instance.chromium.launch(headless=False)
+            context = await browser_instance.new_context()
+        
+        # 一个一个处理URL
+        for i, url in enumerate(urls[:max_urls]):
+            logger.info(f"处理URL {i+1}/{max_urls}: {url}")
+            
+            # 创建一个新页面
+            page = await context.new_page()
+            
+            try:
+                # 提取内容
+                result = await extract_content_from_url(url, page)
+                results.append(result.dict())
+                logger.info(f"成功处理URL: {url}")
+            except Exception as e:
+                logger.error(f"处理URL {url} 时出错: {str(e)}")
+                results.append({
+                    "url": url,
+                    "error": str(e),
+                    "title": "",
+                    "authors": [],
+                    "abstract": "",
+                    "keywords": [],
+                    "cite_format": ""
+                })
+            finally:
+                # 关闭页面
+                await page.close()
+            
+            # 添加短暂延迟，避免过快请求导致被封
+            await asyncio.sleep(1)
+        
+        logger.info(f"批量处理完成，共处理 {len(results)} 个URL")
+        return results
+    except Exception as e:
+        logger.error(f"批量处理过程中出错: {str(e)}")
+        logger.error(traceback.format_exc())
+        return [{"error": f"批量处理过程中出错: {str(e)}"}] + results
+
+# 添加关闭函数，在程序结束时清理资源
+async def cleanup_playwright():
+    """清理playwright资源"""
+    global playwright_instance, browser_instance, context
+    
+    if context:
+        logger.debug("[DEBUG] 关闭playwright上下文")
+        await context.close()
+        context = None
+    
+    if browser_instance:
+        logger.debug("[DEBUG] 关闭浏览器实例")
+        await browser_instance.close()
+        browser_instance = None
+    
+    if playwright_instance:
+        logger.debug("[DEBUG] 关闭playwright实例")
+        await playwright_instance.stop()
+        playwright_instance = None
 
 async def main():
     """主程序入口"""
-    # 使用stdin/stdout流运行服务器
-    async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
-        await server.run(
-            read_stream,
-            write_stream,
-            InitializationOptions(
-                server_name="cnks",
-                server_version="0.2.3",
-                capabilities=server.get_capabilities(
-                    notification_options=NotificationOptions(),
-                    experimental_capabilities={},
+    try:
+        # 使用stdin/stdout流运行服务器
+        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+            await server.run(
+                read_stream,
+                write_stream,
+                InitializationOptions(
+                    server_name="cnks",
+                    server_version="0.3.0",
+                    capabilities=server.get_capabilities(
+                        notification_options=NotificationOptions(),
+                        experimental_capabilities={},
+                    ),
                 ),
-            ),
-        )
+            )
+    finally:
+        # 确保playwright资源在程序结束时被清理
+        await cleanup_playwright()
 
 # 为符合README.md的要求，添加从FastMCP导出的接口
 def create_fastmcp_server():
@@ -775,36 +1773,81 @@ def create_fastmcp_server():
         fast_mcp = FastMCP("知网搜索")
         
         # 只添加搜索并提取的工具
-        if extractor is not None and PLAYWRIGHT_AVAILABLE:
+        if PLAYWRIGHT_AVAILABLE:
             @fast_mcp.tool()
-            async def mcp_cnks_search_and_extract(keywords: str) -> dict:
+            async def search_and_extract(keywords: str) -> dict:
                 """搜索关键词并提取所有论文的详细内容"""
-                logger.debug("[DEBUG] 正在使用FastMCP的mcp_cnks_search_and_extract函数")
+                logger.debug("[DEBUG] 正在使用FastMCP的search_and_extract函数")
                 try:
                     # 第一步：执行搜索
-                    result_count = await search_with_playwright(keywords)
+                    logger.debug(f"[DEBUG] 开始搜索关键词: {keywords}")
+                    
+                    # 构建URL
+                    url = f"https://kns.cnki.net/kns8s/search?q={quote(keywords)}"
+                    logger.debug(f"[DEBUG] 搜索URL: {url}")
+                    
+                    # 如果playwright可用，使用playwright搜索
+                    if PLAYWRIGHT_AVAILABLE:
+                        logger.debug("[DEBUG] 使用playwright搜索")
+                        result_count = await search_with_playwright(keywords)
+                    else:
+                        # 否则直接用open_chrome打开URL
+                        logger.debug("[DEBUG] 直接使用open_chrome打开URL")
+                        result = open_chrome(url)
+                        
+                        if isinstance(result, str):
+                            # 如果是错误信息，返回错误
+                            return {
+                                "error": f"打开Chrome失败: {result}",
+                                "keywords": keywords,
+                                "count": 0,
+                                "results": []
+                            }
+                        else:
+                            # 成功打开但无法获取链接
+                            return {
+                                "keywords": keywords,
+                                "count": 0,
+                                "message": "已直接在Chrome中打开搜索页面，但无法自动获取搜索结果。请安装playwright以获取完整功能。",
+                                "results": []
+                            }
                     
                     # 检查搜索结果
                     if not isinstance(page_content, dict) or "links" not in page_content or not page_content["links"]:
+                        # 如果没有找到链接，至少返回搜索页面作为结果
+                        logger.debug("[DEBUG] 搜索未返回有效链接，返回搜索页面作为结果")
                         return {
-                            "error": "搜索未返回有效链接",
                             "keywords": keywords,
-                            "count": 0,
-                            "results": []
+                            "count": 1,
+                            "results": [{
+                                "title": f"搜索结果: {keywords}",
+                                "authors": [],
+                                "abstract": "请在浏览器中查看搜索结果",
+                                "keywords": [],
+                                "cite_format": "",
+                                "url": url
+                            }]
                         }
                     
                     # 提取链接
                     urls = [link["url"] for link in page_content["links"] if "url" in link]
                     if not urls:
+                        logger.debug("[DEBUG] 没有找到有效链接，返回搜索页面")
                         return {
-                            "error": "未找到有效链接",
                             "keywords": keywords,
-                            "count": 0,
-                            "results": []
+                            "count": 1,
+                            "results": [{
+                                "title": f"搜索结果: {keywords}",
+                                "authors": [],
+                                "abstract": "请在浏览器中查看搜索结果",
+                                "keywords": [],
+                                "cite_format": "",
+                                "url": url
+                            }]
                         }
                     
                     # 第二步：执行提取
-                    results = await extractor.batch_extract_contents(urls)
+                    results = await batch_extract_contents(urls)
                     
                     # 包装结果
                     return {
@@ -816,6 +1859,7 @@ def create_fastmcp_server():
                     }
                 except Exception as e:
                     logger.error(f"搜索并提取时出错: {str(e)}")
+                    logger.error(traceback.format_exc())
                     return {
                         "error": f"搜索并提取内容时出错: {str(e)}",
                         "keywords": keywords,