Qiaomu Anything To Notebooklm

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
env/
venv/
ENV/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
*.egg-info/
.installed.cfg
*.egg

# MCP Server (will be cloned during install)
# Keep the directory but ignore its contents
wexin-read-mcp/

# IDE
.vscode/
.idea/
*.swp
*.swo
*~
.DS_Store

# Logs
*.log

# Environment
.env
.env.local

# Temporary files
tmp/
temp/
*.tmp

# macOS
.DS_Store
.AppleDouble
.LSOverride

#!/usr/bin/env python3
"""
环境检查脚本 - 验证 qiaomu-anything-to-notebooklm skill 所有依赖
"""

import sys
import os
import json
from pathlib import Path

# 颜色输出
RED = '\033[0;31m'
GREEN = '\033[0;32m'
YELLOW = '\033[1;33m'
BLUE = '\033[0;34m'
NC = '\033[0m'

def print_status(status, message):
    """打印状态信息"""
    if status == "ok":
        print(f"{GREEN}✅ {message}{NC}")
    elif status == "warning":
        print(f"{YELLOW}⚠️  {message}{NC}")
    elif status == "error":
        print(f"{RED}❌ {message}{NC}")
    else:
        print(f"{BLUE}ℹ️  {message}{NC}")

def check_python_version():
    """检查 Python 版本"""
    version = sys.version_info
    version_str = f"{version.major}.{version.minor}.{version.micro}"

    if version.major >= 3 and version.minor >= 9:
        print_status("ok", f"Python {version_str}")
        return True
    else:
        print_status("error", f"Python {version_str} (需要 3.9+)")
        return False

def check_module(module_name, import_name=None):
    """检查 Python 模块是否已安装"""
    if import_name is None:
        import_name = module_name

    try:
        __import__(import_name)
        print_status("ok", f"{module_name} 已安装")
        return True
    except ImportError:
        print_status("error", f"{module_name} 未安装")
        return False

def check_command(cmd):
    """检查命令是否可用"""
    import shutil

    if shutil.which(cmd):
        # 尝试获取版本
        import subprocess
        try:
            result = subprocess.run([cmd, "--version"],
                                  capture_output=True,
                                  text=True,
                                  timeout=5)
            version = result.stdout.split('\n')[0] if result.stdout else "unknown"
            print_status("ok", f"{cmd} 已安装 ({version})")
        except:
            print_status("ok", f"{cmd} 已安装")
        return True
    else:
        print_status("error", f"{cmd} 未找到")
        return False

def check_mcp_config():
    """检查 MCP 配置"""
    config_path = Path.home() / ".claude" / "config.json"

    if not config_path.exists():
        print_status("error", f"未找到 Claude 配置文件: {config_path}")
        return False

    try:
        with open(config_path, 'r') as f:
            config = json.load(f)

        if "mcpServers" in config and "weixin-reader" in config["mcpServers"]:
            print_status("ok", "MCP 服务器已配置")
            return True
        else:
            print_status("warning", "MCP 服务器未配置（需要手动添加）")
            return False
    except Exception as e:
        print_status("error", f"无法读取配置文件: {e}")
        return False

def check_mcp_server():
    """检查 MCP 服务器文件"""
    skill_dir = Path(__file__).parent
    mcp_server = skill_dir / "wexin-read-mcp" / "src" / "server.py"

    if mcp_server.exists():
        print_status("ok", f"MCP 服务器文件存在")
        return True
    else:
        print_status("error", f"MCP 服务器文件不存在: {mcp_server}")
        return False

def check_notebooklm_auth():
    """检查 NotebookLM 认证状态"""
    import subprocess

    try:
        result = subprocess.run(["notebooklm", "list"],
                              capture_output=True,
                              text=True,
                              timeout=10)

        if result.returncode == 0:
            print_status("ok", "NotebookLM 已认证")
            return True
        else:
            print_status("warning", "NotebookLM 未认证（请运行 notebooklm login）")
            return False
    except subprocess.TimeoutExpired:
        print_status("warning", "NotebookLM 认证检查超时")
        return False
    except Exception as e:
        print_status("error", f"NotebookLM 认证检查失败: {e}")
        return False

def main():
    print(f"\n{BLUE}========================================{NC}")
    print(f"{BLUE}  环境检查 - qiaomu-anything-to-notebooklm{NC}")
    print(f"{BLUE}========================================{NC}\n")

    results = []

    # 1. Python 版本
    print(f"{YELLOW}[1/8] Python 版本{NC}")
    results.append(check_python_version())
    print()

    # 2. 核心依赖
    print(f"{YELLOW}[2/9] 核心 Python 依赖{NC}")
    results.append(check_module("fastmcp"))
    results.append(check_module("playwright"))
    results.append(check_module("beautifulsoup4", "bs4"))
    results.append(check_module("lxml"))
    results.append(check_module("markitdown"))
    print()

    # 3. Playwright 浏览器
    print(f"{YELLOW}[3/9] Playwright 可导入性{NC}")
    try:
        from playwright.sync_api import sync_playwright
        print_status("ok", "Playwright 可以正常导入")
        results.append(True)
    except Exception as e:
        print_status("error", f"Playwright 导入失败: {e}")
        results.append(False)
    print()

    # 4. NotebookLM CLI
    print(f"{YELLOW}[4/9] NotebookLM CLI{NC}")
    results.append(check_command("notebooklm"))
    print()

    # 5. markitdown CLI
    print(f"{YELLOW}[5/9] markitdown CLI{NC}")
    results.append(check_command("markitdown"))
    print()

    # 6. Git 命令
    print(f"{YELLOW}[6/9] Git 命令{NC}")
    results.append(check_command("git"))
    print()

    # 7. MCP 服务器文件
    print(f"{YELLOW}[7/9] MCP 服务器文件{NC}")
    results.append(check_mcp_server())
    print()

    # 8. MCP 配置
    print(f"{YELLOW}[8/9] MCP 配置{NC}")
    results.append(check_mcp_config())
    print()

    # 9. NotebookLM 认证
    print(f"{YELLOW}[9/9] NotebookLM 认证{NC}")
    results.append(check_notebooklm_auth())
    print()

    # 总结
    print(f"{BLUE}========================================{NC}")
    passed = sum(results)
    total = len(results)

    if passed == total:
        print(f"{GREEN}✅ 所有检查通过 ({passed}/{total})！环境配置完整。{NC}")
    elif passed >= total * 0.8:
        print(f"{YELLOW}⚠️  大部分检查通过 ({passed}/{total})，但有些问题需要修复。{NC}")
    else:
        print(f"{RED}❌ 检查失败 ({passed}/{total})，请运行 install.sh 重新安装。{NC}")

    print(f"{BLUE}========================================{NC}\n")

    if passed < total:
        print("💡 修复建议：")
        print("  1. 运行安装脚本：./install.sh")
        print("  2. 配置 MCP：编辑 ~/.claude/config.json")
        print("  3. 认证 NotebookLM：notebooklm login")
        print()

    sys.exit(0 if passed == total else 1)

if __name__ == "__main__":
    main()

#!/bin/bash

# 飞书文档读取 MCP 服务器安装脚本

set -e

echo "======================================"
echo "  飞书文档读取 MCP 服务器安装"
echo "======================================"
echo ""

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# 检查 Python
if ! command -v python3 &> /dev/null; then
    echo -e "${RED}❌ Python3 未安装${NC}"
    exit 1
fi

echo -e "${GREEN}✓${NC} Python 版本: $(python3 --version)"

# 检查 pip
if ! command -v pip3 &> /dev/null; then
    echo -e "${RED}❌ pip3 未安装${NC}"
    exit 1
fi

echo -e "${GREEN}✓${NC} pip 版本: $(pip3 --version)"

# 1. 安装 Python 依赖
echo ""
echo -e "${YELLOW}[1/3]${NC} 安装 Python 依赖..."
pip3 install -r requirements.txt

echo -e "${GREEN}✓${NC} Python 依赖安装完成"

# 2. 安装 Playwright 浏览器
echo ""
echo -e "${YELLOW}[2/3]${NC} 安装 Playwright 浏览器..."

if ! command -v playwright &> /dev/null; then
    echo "安装 Playwright CLI..."
    pip3 install playwright

    echo "安装浏览器..."
    playwright install chromium
else
    echo "Playwright 已安装，更新浏览器..."
    playwright install chromium
fi

echo -e "${GREEN}✓${NC} Playwright 浏览器安装完成"

# 3. 创建临时目录
echo ""
echo -e "${YELLOW}[3/3]${NC} 创建临时目录..."
mkdir -p /tmp/feishu_docs
mkdir -p /tmp/feishu_images

echo -e "${GREEN}✓${NC} 临时目录创建完成"

# 测试安装
echo ""
echo -e "${YELLOW}测试安装...${NC}"

python3 -c "
import sys
sys.path.insert(0, 'src')

try:
    from scraper import FeishuScraper
    from parser import FeishuParser
    from image_handler import ImageHandler
    print('✓ 所有模块导入成功')
except ImportError as e:
    print(f'✗ 模块导入失败: {e}')
    sys.exit(1)
"

echo ""
echo -e "${GREEN}======================================${NC}"
echo -e "${GREEN}安装完成！${NC}"
echo -e "${GREEN}======================================${NC}"
echo ""
echo "下一步："
echo "1. 配置 MCP 服务器（在 Claude Code 配置文件中）"
echo "2. 重启 Claude Code"
echo "3. 开始使用！"
echo ""
echo "配置文件示例："
cat << 'EOF'

{
  "mcpServers": {
    "feishu-reader": {
      "command": "python",
      "args": [
        "/path/to/feishu-read-mcp/src/server.py"
      ]
    }
  }
}

EOF

echo ""
echo "详细文档请查看 README.md"

# MCP 服务器核心依赖
fastmcp>=0.2.0

# 浏览器自动化
playwright>=1.40.0

# HTTP 请求
aiohttp>=3.9.0
aiofiles>=23.0.0

# HTML 解析
beautifulsoup4>=4.12.0
lxml>=4.9.0

# 图片处理
Pillow>=10.0.0

# 其他工具
aiofiles>=23.0.0
aiohttp-client-cache>=0.6.0

"""飞书文档读取 MCP 服务器"""

__version__ = "1.0.0"
__author__ = "joeseesun"

from .server import mcp
from .scraper import FeishuScraper
from .parser import FeishuParser
from .image_handler import ImageHandler

__all__ = [
    "mcp",
    "FeishuScraper",
    "FeishuParser",
    "ImageHandler"
]

"""图片处理器"""

import asyncio
import hashlib
import logging
from pathlib import Path
from typing import List, Dict, Optional
from urllib.parse import urljoin, urlparse
import aiohttp
from aiohttp import ClientTimeout
import io
from PIL import Image
import json

logger = logging.getLogger(__name__)


class ImageHandler:
    """飞书文档图片处理器"""

    def __init__(self, cookies_str: Optional[str] = None):
        """
        初始化图片处理器

        Args:
            cookies_str: 可选的cookie字符串
        """
        self.image_dir = Path("/tmp/feishu_images")
        self.image_dir.mkdir(parents=True, exist_ok=True)
        self.timeout = ClientTimeout(total=30, connect=10)
        self.cookies_str = cookies_str

    async def download_images(self, image_urls: List[str]) -> Dict[str, str]:
        """
        批量下载图片

        Args:
            image_urls: 图片URL列表

        Returns:
            Dict[str, str]: {原始URL: 本地路径} 的映射
        """
        if not image_urls:
            return {}

        logger.info(f"Starting to download {len(image_urls)} images...")

        # 准备headers
        headers = {
            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
        }

        # 准备cookies（如果提供）
        cookies = None
        if self.cookies_str:
            cookie_list = []
            for cookie_pair in self.cookies_str.split(';'):
                if '=' in cookie_pair:
                    key, value = cookie_pair.strip().split('=', 1)
                    cookie_list.append({
                        'name': key,
                        'value': value,
                        'domain': '.feishu.cn'
                    })
            cookies = cookie_list

        # 创建会话
        async with aiohttp.ClientSession(timeout=self.timeout, headers=headers, cookies=cookies) as session:
            # 并发下载（限制并发数为5）
            semaphore = asyncio.Semaphore(5)

            async def download_single(url: str) -> tuple[str, str]:
                """下载单个图片"""
                async with semaphore:
                    return await self._download_image(session, url)

            # 执行并发下载
            results = await asyncio.gather(
                *[download_single(url) for url in image_urls],
                return_exceptions=True
            )

            # 过滤结果
            downloaded = {}
            for result in results:
                if isinstance(result, tuple):
                    original_url, local_path = result
                    downloaded[original_url] = local_path

        logger.info(f"Successfully downloaded {len(downloaded)} images")

        return downloaded

    async def _download_image(self, session: aiohttp.ClientSession, url: str) -> tuple[str, str]:
        """
        下载单个图片

        Args:
            session: aiohttp 会话
            url: 图片URL

        Returns:
            tuple: (原始URL, 本地路径)
        """
        try:
            # 生成文件名
            file_hash = hashlib.md5(url.encode()).hexdigest()
            file_ext = self._get_file_extension(url)
            file_path = self.image_dir / f"{file_hash}{file_ext}"

            # 如果文件已存在，直接返回
            if file_path.exists():
                logger.debug(f"Image already exists: {file_path}")
                return url, str(file_path)

            # 发起请求
            async with session.get(url) as response:
                # 跳过认证错误和其他客户端错误
                if response.status in [401, 403]:
                    logger.warning(f"Skipping image {url}: Authentication required (HTTP {response.status})")
                    return url, url  # 返回原始URL
                if response.status != 200:
                    logger.warning(f"Failed to download image {url}: HTTP {response.status}")
                    return url, url  # 返回原始URL

                # 读取图片数据
                content = await response.read()

                # 验证图片格式
                if not self._is_valid_image(content):
                    logger.warning(f"Invalid image format for {url}")
                    return url, url

                # 优化图片（可选）
                optimized_content = await self._optimize_image(content)

                # 保存到本地
                with open(file_path, 'wb') as f:
                    f.write(optimized_content)

                logger.debug(f"Downloaded image: {file_path}")
                return url, str(file_path)

        except asyncio.TimeoutError:
            logger.error(f"Timeout downloading image: {url}")
            return url, url
        except Exception as e:
            logger.error(f"Error downloading image {url}: {e}")
            return url, url

    def _get_file_extension(self, url: str) -> str:
        """
        从 URL 获取文件扩展名

        Args:
            url: 图片URL

        Returns:
            str: 文件扩展名
        """
        parsed = urlparse(url)
        path = parsed.path

        # 常见的图片扩展名
        extensions = ['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.bmp']

        for ext in extensions:
            if path.lower().endswith(ext):
                return ext

        # 默认扩展名
        return '.png'

    def _is_valid_image(self, content: bytes) -> bool:
        """
        验证是否为有效的图片

        Args:
            content: 图片二进制数据

        Returns:
            bool: 是否为有效图片
        """
        # 检查文件大小（太小或太大都认为无效）
        if len(content) < 100 or len(content) > 10 * 1024 * 1024:
            return False

        # 检查文件头
        image_signatures = {
            b'\x89PNG': 'png',
            b'\xff\xd8\xff': 'jpeg',
            b'GIF8': 'gif',
            b'RIFF': 'webp',  # WebP 文件头
            b'BM': 'bmp'
        }

        for signature in image_signatures:
            if content.startswith(signature):
                return True

        return False

    async def _optimize_image(self, content: bytes) -> bytes:
        """
        优化图片（压缩、转换格式等）

        Args:
            content: 原始图片数据

        Returns:
            bytes: 优化后的图片数据
        """
        try:
            # 如果内容太大，进行压缩
            if len(content) > 1024 * 1024:  # 大于1MB
                image = Image.open(io.BytesIO(content))

                # 如果是 RGBA，转换为 RGB（JPEG 不支持透明度）
                if image.mode == 'RGBA':
                    # 创建白色背景
                    background = Image.new('RGB', image.size, (255, 255, 255))
                    background.paste(image, mask=image.split()[-1])
                    image = background
                elif image.mode != 'RGB':
                    image = image.convert('RGB')

                # 限制最大尺寸
                max_size = (1920, 1080)
                image.thumbnail(max_size, Image.Resampling.LANCZOS)

                # 保存为 JPEG（质量85）
                output = io.BytesIO()
                image.save(output, format='JPEG', quality=85, optimize=True)

                return output.getvalue()

            return content

        except Exception as e:
            logger.warning(f"Failed to optimize image: {e}")
            return content

    async def download_single_image(self, url: str, session: aiohttp.ClientSession) -> str:
        """
        下载单个图片并返回本地路径

        Args:
            url: 图片URL
            session: aiohttp 会话

        Returns:
            str: 本地文件路径
        """
        _, local_path = await self._download_image(session, url)
        return local_path

    def get_image_info(self, image_path: str) -> Dict:
        """
        获取图片信息

        Args:
            image_path: 图片路径

        Returns:
            Dict: 图片信息（尺寸、大小等）
        """
        try:
            path = Path(image_path)
            if not path.exists():
                return {}

            image = Image.open(path)
            return {
                "path": str(path),
                "width": image.width,
                "height": image.height,
                "mode": image.mode,
                "format": image.format,
                "size": path.stat().st_size
            }
        except Exception as e:
            logger.error(f"Error getting image info for {image_path}: {e}")
            return {}

    async def cleanup(self):
        """清理临时图片文件"""
        try:
            # 删除7天前的临时图片
            import time
            now = time.time()
            seven_days_ago = now - 7 * 24 * 60 * 60

            for file_path in self.image_dir.glob('*'):
                if file_path.is_file():
                    mtime = file_path.stat().st_mtime
                    if mtime < seven_days_ago:
                        file_path.unlink()
                        logger.debug(f"Cleaned up old image: {file_path}")
        except Exception as e:
            logger.error(f"Error cleaning up images: {e}")

"""飞书文档内容解析器"""

import re
import logging
from typing import List, Dict, Optional, Tuple
from bs4 import BeautifulSoup, Tag, NavigableString
from urllib.parse import urljoin, urlparse

logger = logging.getLogger(__name__)


class FeishuParser:
    """飞书文档 HTML 解析器"""

    def __init__(self):
        # 映射图片URL到本地路径
        self.image_map: Dict[str, str] = {}

    def parse_html(self, html: str) -> List[Dict]:
        """
        解析 HTML 为结构化数据

        Args:
            html: HTML 字符串

        Returns:
            List[Dict]: 内容块列表
        """
        soup = BeautifulSoup(html, 'html.parser')
        blocks = []

        # 处理所有内容块
        for element in soup.find_all(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
                                     'ul', 'ol', 'blockquote', 'pre', 'table']):
            block = self._parse_element(element)
            if block:
                blocks.append(block)

        return blocks

    def _parse_element(self, element) -> Optional[Dict]:
        """
        解析单个元素

        Args:
            element: BeautifulSoup 元素

        Returns:
            Dict: 解析后的内容块
        """
        tag_name = element.name.lower()

        # 标题
        if tag_name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
            level = int(tag_name[1])
            text = self._clean_text(element)
            return {
                'type': 'heading',
                'level': level,
                'text': text
            }

        # 段落
        if tag_name == 'p':
            text = self._clean_text(element)
            if text.strip():
                return {
                    'type': 'paragraph',
                    'text': text
                }

        # 列表
        if tag_name in ['ul', 'ol']:
            items = []
            for li in element.find_all('li', recursive=False):
                item_text = self._clean_text(li)
                if item_text.strip():
                    items.append(item_text)

            return {
                'type': 'list',
                'ordered': tag_name == 'ol',
                'items': items
            }

        # 引用
        if tag_name == 'blockquote':
            text = self._clean_text(element)
            return {
                'type': 'quote',
                'text': text
            }

        # 代码块
        if tag_name == 'pre':
            code_text = element.get_text(strip=False)
            return {
                'type': 'code',
                'language': self._detect_language(element),
                'text': code_text
            }

        # 表格
        if tag_name == 'table':
            return self._parse_table(element)

        # 图片
        if tag_name == 'img':
            src = element.get('src', '')
            alt = element.get('alt', '')
            return {
                'type': 'image',
                'src': src,
                'alt': alt
            }

        # 链接
        if tag_name == 'a':
            href = element.get('href', '')
            text = self._clean_text(element)
            return {
                'type': 'link',
                'href': href,
                'text': text
            }

        return None

    def _parse_table(self, table) -> Dict:
        """
        解析表格

        Args:
            table: 表格元素

        Returns:
            Dict: 表格数据
        """
        rows = []

        # 获取表头
        thead = table.find('thead')
        header_row = None
        if thead:
            header_row = thead.find('tr')
            if header_row:
                headers = [self._clean_text(th) for th in header_row.find_all(['th', 'td'])]
                rows.append(headers)

        # 获取表格内容
        tbody = table.find('tbody')
        if tbody:
            for tr in tbody.find_all('tr'):
                row = [self._clean_text(td) for td in tr.find_all(['td', 'th'])]
                if row:
                    rows.append(row)

        # 如果没有 tbody，直接解析所有行
        if not tbody:
            for tr in table.find_all('tr'):
                row = [self._clean_text(td) for td in tr.find_all(['td', 'th'])]
                if row:
                    rows.append(row)

        return {
            'type': 'table',
            'rows': rows
        }

    def _clean_text(self, element) -> str:
        """
        清理元素文本

        Args:
            element: BeautifulSoup 元素

        Returns:
            str: 清理后的文本
        """
        # 获取纯文本，保留换行
        text = element.get_text(separator=' ', strip=True)

        # 清理多余的空白字符
        text = re.sub(r'\s+', ' ', text)

        return text

    def _detect_language(self, element) -> str:
        """
        检测代码语言

        Args:
            element: 代码块元素

        Returns:
            str: 语言名称
        """
        # 尝试从 class 或其他属性获取语言信息
        classes = element.get('class', [])
        for cls in classes:
            if 'language-' in cls:
                return cls.replace('language-', '')

        # 尝试从父元素获取
        parent = element.parent
        if parent:
            classes = parent.get('class', [])
            for cls in classes:
                if 'language-' in cls:
                    return cls.replace('language-', '')

        return ''

    def generate_markdown(self, blocks: List[Dict], image_map: Dict[str, str]) -> str:
        """
        生成 Markdown

        Args:
            blocks: 内容块列表
            image_map: 图片映射 {URL: 本地路径}

        Returns:
            str: Markdown 字符串
        """
        markdown_parts = []
        self.image_map = image_map

        for block in blocks:
            md = self._block_to_markdown(block)
            if md:
                markdown_parts.append(md)

        return '\n\n'.join(markdown_parts)

    def _block_to_markdown(self, block: Dict) -> str:
        """
        将内容块转换为 Markdown

        Args:
            block: 内容块

        Returns:
            str: Markdown 字符串
        """
        block_type = block.get('type')

        if block_type == 'heading':
            level = block.get('level', 1)
            text = block.get('text', '')
            return f"{'#' * level} {text}"

        if block_type == 'paragraph':
            return block.get('text', '')

        if block_type == 'list':
            items = block.get('items', [])
            ordered = block.get('ordered', False)
            md_items = []

            for i, item in enumerate(items):
                if ordered:
                    md_items.append(f"{i + 1}. {item}")
                else:
                    md_items.append(f"- {item}")

            return '\n'.join(md_items)

        if block_type == 'quote':
            text = block.get('text', '')
            # 添加 > 前缀
            lines = text.split('\n')
            quoted_lines = [f"> {line}" if line.strip() else ">" for line in lines]
            return '\n'.join(quoted_lines)

        if block_type == 'code':
            language = block.get('language', '')
            text = block.get('text', '')

            if language:
                return f"```{language}\n{text}\n```"
            else:
                return f"```\n{text}\n```"

        if block_type == 'table':
            return self._table_to_markdown(block)

        if block_type == 'image':
            src = block.get('src', '')
            alt = block.get('alt', '')

            # 获取本地路径
            local_path = self.image_map.get(src, src)

            if alt:
                return f"![{alt}]({local_path})"
            else:
                return f"![]({local_path})"

        if block_type == 'link':
            href = block.get('href', '')
            text = block.get('text', '')

            if text == href:
                return f"<{href}>"
            else:
                return f"[{text}]({href})"

        return ''

    def _table_to_markdown(self, block: Dict) -> str:
        """
        将表格转换为 Markdown

        Args:
            block: 表格数据

        Returns:
            str: Markdown 表格
        """
        rows = block.get('rows', [])
        if not rows:
            return ''

        markdown_lines = []

        # 表头
        if rows:
            markdown_lines.append('| ' + ' | '.join(rows[0]) + ' |')

        # 分隔线
        if rows:
            markdown_lines.append('| ' + ' | '.join(['---'] * len(rows[0])) + ' |')

        # 表格内容
        for row in rows[1:]:
            markdown_lines.append('| ' + ' | '.join(row) + ' |')

        return '\n'.join(markdown_lines)

    def extract_text(self, blocks: List[Dict]) -> str:
        """
        提取纯文本

        Args:
            blocks: 内容块列表

        Returns:
            str: 纯文本
        """
        text_parts = []

        for block in blocks:
            block_type = block.get('type')

            if block_type == 'heading':
                text_parts.append(block.get('text', ''))

            elif block_type == 'paragraph':
                text_parts.append(block.get('text', ''))

            elif block_type == 'list':
                items = block.get('items', [])
                text_parts.extend(items)

            elif block_type == 'quote':
                text_parts.append(block.get('text', ''))

            elif block_type == 'code':
                text_parts.append(block.get('text', ''))

            elif block_type == 'table':
                rows = block.get('rows', [])
                for row in rows:
                    text_parts.extend(row)

            elif block_type == 'image':
                alt = block.get('alt', '')
                if alt:
                    text_parts.append(alt)

        return ' '.join(text_parts)

    def extract_images(self, blocks: List[Dict]) -> List[str]:
        """
        提取所有图片URL

        Args:
            blocks: 内容块列表

        Returns:
            List[str]: 图片URL列表
        """
        images = []

        for block in blocks:
            if block.get('type') == 'image':
                src = block.get('src', '')
                if src:
                    images.append(src)

        return images

"""飞书文档抓取器"""

import asyncio
import re
import json
from typing import List, Dict, Optional, Tuple
from pathlib import Path
from urllib.parse import urljoin, urlparse
import logging

try:
    from playwright.async_api import async_playwright, Browser, Page, BrowserContext
except ImportError:
    logging.error("playwright not installed. Run: pip install playwright")
    raise

try:
    from .image_handler import ImageHandler
    from .parser import FeishuParser
except ImportError:
    from image_handler import ImageHandler
    from parser import FeishuParser

logger = logging.getLogger(__name__)


class FeishuScraper:
    """飞书文档抓取器"""

    def __init__(self, cookies_str: Optional[str] = None):
        """
        初始化飞书抓取器

        Args:
            cookies_str: 可选的cookie字符串，格式: "key1=value1; key2=value2"
        """
        self.playwright = None
        self.browser = None
        self.context = None
        self.image_handler = ImageHandler()
        self.parser = FeishuParser()
        self.temp_dir = Path("/tmp/feishu_docs")
        self.temp_dir.mkdir(parents=True, exist_ok=True)
        self.cookies_str = cookies_str

    async def __aenter__(self):
        """异步上下文管理器入口"""
        await self.init()
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        """异步上下文管理器退出"""
        await self.cleanup()

    async def init(self):
        """初始化 Playwright"""
        if not self.playwright:
            self.playwright = await async_playwright().start()
            self.browser = await self.playwright.chromium.launch(
                headless=True,
                args=[
                    '--no-sandbox',
                    '--disable-setuid-sandbox',
                    '--disable-dev-shm-usage',
                    '--disable-gpu'
                ]
            )

            # 准备cookies（如果提供）
            cookies = None
            if self.cookies_str:
                cookies = []
                for cookie_pair in self.cookies_str.split(';'):
                    if '=' in cookie_pair:
                        key, value = cookie_pair.strip().split('=', 1)
                        cookies.append({
                            'name': key,
                            'value': value,
                            'domain': '.feishu.cn'
                        })

            self.context = await self.browser.new_context(
                viewport={'width': 1920, 'height': 1080},
                extra_http_headers={
                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
                },
                cookies=cookies
            )

    async def cleanup(self):
        """清理资源"""
        if self.context:
            await self.context.close()
        if self.browser:
            await self.browser.close()
        if self.playwright:
            await self.playwright.stop()

    async def fetch_doc(self, url: str) -> dict:
        """
        获取飞书文档并转换为 Markdown

        Args:
            url: 飞书文档URL

        Returns:
            dict: 包含标题、内容、作者、图片等信息的字典
        """
        page = await self.context.new_page()

        try:
            # 1. 打开页面
            logger.info(f"Navigating to: {url}")
            await page.goto(url, wait_until='domcontentloaded', timeout=60000)

            # 2. 等待内容加载
            logger.info("Waiting for content to load...")
            # 初始等待5秒
            await page.wait_for_timeout(5000)

            # 等待加载指示器消失
            try:
                await page.wait_for_function(
                    """() => {
                        const loaders = document.querySelectorAll('.loading, .spinner, [class*="loading"]');
                        return loaders.length === 0;
                    }""",
                    timeout=10000
                )
            except:
                logger.warning("Could not find/disable loading indicator, continuing...")

            # 3. 获取基本信息
            title = await self._extract_title(page)
            author = await self._extract_author(page)

            # 4. 等待文档内容加载
            logger.info("Waiting for document content to appear...")

            # 等待动态渲染完成 - 使用 body 文本长度作为指标
            max_wait_time = 30000  # 30秒
            check_interval = 1000  # 每秒检查
            waited_time = 0

            while waited_time < max_wait_time:
                body_text = await page.evaluate("() => document.body.innerText.trim()")
                if len(body_text) > 500:  # 如果body文本超过500字符，认为内容已加载
                    logger.info(f"Document content detected, body text length: {len(body_text)}")
                    break
                await page.wait_for_timeout(check_interval)
                waited_time += check_interval

            if waited_time >= max_wait_time:
                logger.warning("Document content not fully loaded within timeout, proceeding with available content")

            # 5. 提取内容
            content_html = await page.evaluate("""
                () => {
                    // 首先尝试直接提取 body.innerText 作为备用
                    const bodyText = document.body.innerText.trim();
                    if (bodyText.length > 500) {
                        console.log('Using body.innerText as primary source, length:', bodyText.length);

                        // 注意：不进行内容过滤，保留所有原始文本
                        // 如果需要清理噪音内容，应该在前端或后处理阶段根据实际需求处理
                        const cleanText = bodyText;

                        // 将清理后的文本转换为HTML，更好地保留段落结构
                        let paragraphs = [];

                        // 先按双换行分割
                        const parts = cleanText.split('\\n\\n');
                        for (let part of parts) {
                            part = part.trim();
                            if (part.length === 0) continue;

                            // 过滤掉太短的段落
                            if (part.length < 10) continue;

                            // 如果这个部分太长，进一步按单换行分割
                            if (part.length > 300) {
                                const subParts = part.split('\\n');
                                let currentPara = '';
                                for (let subPart of subParts) {
                                    subPart = subPart.trim();
                                    if (subPart.length === 0) {
                                        if (currentPara.length > 0) {
                                            paragraphs.push(currentPara);
                                            currentPara = '';
                                        }
                                    } else {
                                        currentPara += (currentPara ? ' ' : '') + subPart;
                                    }
                                }
                                if (currentPara.length > 0) {
                                    paragraphs.push(currentPara);
                                }
                            } else {
                                paragraphs.push(part);
                            }
                        }

                        if (paragraphs.length > 0) {
                            return paragraphs.map(p => '<p>' + p.replace(/\\n/g, ' ').replace(/\\s+/g, ' ').trim() + '</p>').join('\\n');
                        }
                    }

                    // 查找文档内容容器
                    const contentSelectors = [
                        'div[contenteditable="true"]',
                        '.larkui-theme-default',
                        '.document',
                        '.feishu-docs-content',
                        '.page-container',
                        '.wiki-page',
                        'main',
                        '[data-docx-id]'
                    ];

                    for (const selector of contentSelectors) {
                        const elements = document.querySelectorAll(selector);
                        for (const element of elements) {
                            if (element.innerText.trim().length > 100) {  // 降低阈值到100字符
                                console.log('Found content with selector:', selector, 'length:', element.innerText.length);
                                return element.innerHTML;
                            }
                        }
                    }

                    // 如果都找不到，使用包含最多文本的容器
                    const allElements = document.querySelectorAll('body > *');
                    let maxText = 0;
                    let result = '';
                    for (const element of allElements) {
                        const text = element.innerText.trim();
                        if (text.length > maxText && text.length > 100) {
                            maxText = text.length;
                            result = element.innerHTML;
                        }
                    }

                    console.log('Using fallback, max text length:', maxText);
                    return result || document.body.innerHTML;
                }
            """)

            # 6. 提取图片URL
            logger.info("Extracting images...")
            image_urls = await self._extract_image_urls(page)
            logger.info(f"Found {len(image_urls)} image URLs")

            # 7. 解析内容为结构化数据
            content_blocks = self.parser.parse_html(content_html)

            # 8. 下载图片
            logger.info(f"Downloading {len(image_urls)} images...")
            local_images = await self.image_handler.download_images(image_urls)

            # 9. 生成 Markdown
            markdown_content = self.parser.generate_markdown(
                content_blocks,
                local_images
            )

            # 10. 计算字数
            word_count = len(markdown_content.replace('\n', '').replace(' ', ''))

            logger.info(f"Successfully processed document: {title}")
            logger.info(f"Word count: {word_count}, Images: {len(local_images)}")

            return {
                "success": True,
                "title": title,
                "author": author or "Unknown",
                "content": markdown_content,
                "images": local_images,
                "word_count": word_count,
                "image_count": len(local_images),
                "url": url
            }

        except Exception as e:
            logger.error(f"Error fetching document: {e}", exc_info=True)
            return {
                "success": False,
                "error": str(e)
            }
        finally:
            await page.close()

    async def get_doc_info(self, url: str) -> dict:
        """
        获取文档基本信息（不下载完整内容）

        Args:
            url: 飞书文档URL

        Returns:
            dict: 基本信息
        """
        page = await self.context.new_page()

        try:
            await page.goto(url, wait_until='networkidle', timeout=30000)
            await page.wait_for_timeout(2000)

            title = await self._extract_title(page)
            author = await self._extract_author(page)

            # 简单估算字数
            word_count = await page.evaluate("""
                () => {
                    const text = document.body.innerText || '';
                    return text.replace(/\\s+/g, '').length;
                }
            """)

            # 简单估算图片数
            image_count = await page.evaluate("""
                () => {
                    return document.querySelectorAll('img').length;
                }
            """)

            return {
                "success": True,
                "title": title,
                "author": author or "Unknown",
                "word_count": word_count,
                "image_count": image_count
            }

        except Exception as e:
            logger.error(f"Error getting doc info: {e}", exc_info=True)
            return {
                "success": False,
                "error": str(e)
            }
        finally:
            await page.close()

    async def _extract_title(self, page: Page) -> str:
        """提取文档标题"""
        try:
            title = await page.title()
            if title:
                return title.strip()
        except:
            pass

        try:
            title = await page.evaluate("""
                () => {
                    // 尝试多种方式获取标题
                    const titleSelectors = [
                        'h1',
                        '.document-title',
                        '.title',
                        '[data-testid="title"]'
                    ];

                    for (const selector of titleSelectors) {
                        const element = document.querySelector(selector);
                        if (element && element.innerText.trim()) {
                            return element.innerText.trim();
                        }
                    }

                    // 如果都找不到，使用页面标题
                    return document.title || 'Unknown Title';
                }
            """)
            return title if title else "Unknown Title"
        except:
            return "Unknown Title"

    async def _extract_author(self, page: Page) -> Optional[str]:
        """提取作者"""
        try:
            author = await page.evaluate("""
                () => {
                    // 尝试多种方式获取作者
                    const authorSelectors = [
                        '.author',
                        '.creator',
                        '[data-testid="author"]',
                        '.user-avatar'
                    ];

                    for (const selector of authorSelectors) {
                        const element = document.querySelector(selector);
                        if (element) {
                            const text = element.innerText || element.getAttribute('title');
                            if (text && text.trim()) {
                                return text.trim();
                            }
                        }
                    }

                    return null;
                }
            """)
            return author if author else None
        except:
            return None

    async def _extract_image_urls(self, page: Page) -> List[str]:
        """提取页面中的所有图片URL"""
        try:
            urls = await page.evaluate("""
                () => {
                    const images = document.querySelectorAll('img');
                    const urls = [];

                    for (const img of images) {
                        let src = img.getAttribute('src') || img.getAttribute('data-src') || img.getAttribute('data-lazy-src');

                        if (src) {
                            // 处理相对路径
                            if (src.startsWith('/')) {
                                src = window.location.origin + src;
                            }

                            // 过滤掉小图标和头像
                            const lowerSrc = src.toLowerCase();
                            if (!lowerSrc.includes('icon') &&
                                !lowerSrc.includes('avatar') &&
                                !lowerSrc.includes('logo') &&
                                !lowerSrc.includes('favicon')) {
                                urls.push(src);
                            }
                        }
                    }

                    // 去重
                    return [...new Set(urls)];
                }
            """)

            logger.info(f"Extracted {len(urls)} image URLs")
            return urls if urls else []
        except Exception as e:
            logger.error(f"Error extracting image URLs: {e}")
            return []


# 便捷函数
async def fetch_feishu_doc(url: str, cookies_str: Optional[str] = None) -> dict:
    """
    便捷函数：直接获取飞书文档

    Args:
        url: 飞书文档URL
        cookies_str: 可选的cookie字符串，格式: "key1=value1; key2=value2"
    """
    async with FeishuScraper(cookies_str=cookies_str) as scraper:
        return await scraper.fetch_doc(url)


async def get_feishu_doc_info(url: str, cookies_str: Optional[str] = None) -> dict:
    """
    便捷函数：获取文档基本信息

    Args:
        url: 飞书文档URL
        cookies_str: 可选的cookie字符串
    """
    async with FeishuScraper(cookies_str=cookies_str) as scraper:
        return await scraper.get_doc_info(url)

"""MCP服务器主入口"""

import sys
from pathlib import Path

# 添加src目录到Python路径，支持直接运行
if __name__ == "__main__":
    src_dir = Path(__file__).parent
    if str(src_dir) not in sys.path:
        sys.path.insert(0, str(src_dir))

from fastmcp import FastMCP
import logging

# 支持相对导入和绝对导入
try:
    from .scraper import FeishuScraper
except ImportError:
    from scraper import FeishuScraper

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# 初始化MCP服务
mcp = FastMCP("feishu-reader")

# 初始化爬虫（全局单例）
scraper = FeishuScraper()


@mcp.tool()
async def read_feishu_doc(url: str, cookies_str: Optional[str] = None) -> dict:
    """
    读取飞书文档内容并转换为 Markdown（支持图片）

    Args:
        url: 飞书文档URL，格式:
            - https://bytedance.feishu.cn/docs/docc/xxx
            - https://xxx.feishu.cn/docs/docc/xxx
        cookies_str: 可选的cookie字符串，格式: "key1=value1; key2=value2"
                      如果提供，可以下载需要认证的图片

    Returns:
        dict: {
            "success": bool,
            "title": str,
            "author": str,
            "content": str,  # Markdown 格式
            "images": List[str],  # 本地图片路径列表
            "word_count": int,
            "error": str | None
        }
    """
    try:
        # URL验证
        if not ("feishu.cn" in url or "feishu.com" in url):
            return {
                "success": False,
                "error": "Invalid URL format. Must be a Feishu document URL."
            }

        logger.info(f"Fetching Feishu document: {url}")

        # 使用cookie创建新的scraper实例
        scraper_instance = FeishuScraper(cookies_str=cookies_str)
        await scraper_instance.init()

        try:
            # 调用爬虫获取内容
            result = await scraper_instance.fetch_doc(url)

            if result.get("success"):
                logger.info(f"Successfully fetched: {result.get('title', 'Unknown')}")
                logger.info(f"Extracted {result.get('word_count', 0)} words and {len(result.get('images', []))} images")
            else:
                logger.error(f"Failed to fetch: {result.get('error')}")

            return result
        finally:
            await scraper_instance.cleanup()

    except Exception as e:
        logger.error(f"Error fetching Feishu document: {e}", exc_info=True)
        return {
            "success": False,
            "error": str(e)
        }


@mcp.tool()
async def get_doc_info(url: str) -> dict:
    """
    获取飞书文档的基本信息（不下载内容）

    Args:
        url: 飞书文档URL

    Returns:
        dict: {
            "success": bool,
            "title": str,
            "author": str,
            "word_count": int,
            "image_count": int,
            "error": str | None
        }
    """
    try:
        result = await scraper.get_doc_info(url)
        return result
    except Exception as e:
        logger.error(f"Error getting doc info: {e}", exc_info=True)
        return {
            "success": False,
            "error": str(e)
        }


# 清理函数
async def cleanup():
    """清理资源"""
    await scraper.cleanup()


if __name__ == "__main__":
    # 支持命令行直接运行
    mcp.run()

#!/usr/bin/env python3
"""测试脚本"""

import asyncio
import sys
from pathlib import Path

# 添加 src 目录到路径
src_dir = Path(__file__).parent / 'src'
sys.path.insert(0, str(src_dir))

from scraper import FeishuScraper


async def test_basic():
    """测试基本功能"""
    print("=" * 50)
    print("测试 1：测试基本导入")
    print("=" * 50)

    try:
        from scraper import FeishuScraper
        from parser import FeishuParser
        from image_handler import ImageHandler
        print("✓ 所有模块导入成功")
        return True
    except ImportError as e:
        print(f"✗ 模块导入失败: {e}")
        return False


async def test_scraper_init():
    """测试爬虫初始化"""
    print("\n" + "=" * 50)
    print("测试 2：测试爬虫初始化")
    print("=" * 50)

    try:
        scraper = FeishuScraper()
        await scraper.init()
        print("✓ 爬虫初始化成功")
        await scraper.cleanup()
        return True
    except Exception as e:
        print(f"✗ 爬虫初始化失败: {e}")
        return False


async def test_parser():
    """测试解析器"""
    print("\n" + "=" * 50)
    print("测试 3：测试解析器")
    print("=" * 50)

    try:
        from parser import FeishuParser

        parser = FeishuParser()

        # 测试 HTML 解析
        html = """
        <h1>测试标题</h1>
        <p>这是一个测试段落。</p>
        <ul>
            <li>列表项 1</li>
            <li>列表项 2</li>
        </ul>
        """

        blocks = parser.parse_html(html)
        print(f"✓ 解析了 {len(blocks)} 个内容块")

        # 测试 Markdown 生成
        markdown = parser.generate_markdown(blocks, {})
        print("✓ Markdown 生成成功")
        print("\n生成的 Markdown:")
        print(markdown)

        return True
    except Exception as e:
        print(f"✗ 解析器测试失败: {e}")
        import traceback
        traceback.print_exc()
        return False


async def test_image_handler():
    """测试图片处理器"""
    print("\n" + "=" * 50)
    print("测试 4：测试图片处理器")
    print("=" * 50)

    try:
        from image_handler import ImageHandler

        handler = ImageHandler()
        print(f"✓ 图片处理器初始化成功，目录: {handler.image_dir}")

        return True
    except Exception as e:
        print(f"✗ 图片处理器测试失败: {e}")
        return False


async def main():
    """主测试函数"""
    print("\n" + "=" * 50)
    print("飞书文档读取 MCP 服务器测试")
    print("=" * 50)

    tests = [
        test_basic,
        test_scraper_init,
        test_parser,
        test_image_handler
    ]

    passed = 0
    failed = 0

    for test in tests:
        try:
            if await test():
                passed += 1
            else:
                failed += 1
        except Exception as e:
            print(f"\n✗ 测试异常: {e}")
            import traceback
            traceback.print_exc()
            failed += 1

    print("\n" + "=" * 50)
    print("测试总结")
    print("=" * 50)
    print(f"✓ 通过: {passed}")
    print(f"✗ 失败: {failed}")
    print(f"总计: {passed + failed}")

    if failed == 0:
        print("\n🎉 所有测试通过！")
        return 0
    else:
        print(f"\n⚠️  {failed} 个测试失败")
        return 1


if __name__ == "__main__":
    exit_code = asyncio.run(main())
    sys.exit(exit_code)

#!/bin/bash

# qiaomu-anything-to-notebooklm Skill Installer
# 自动安装所有依赖并配置环境

set -e  # 遇到错误立即退出

SKILL_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SKILL_NAME="qiaomu-anything-to-notebooklm"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

echo -e "${BLUE}========================================${NC}"
echo -e "${BLUE}  多源内容 → NotebookLM 安装程序${NC}"
echo -e "${BLUE}========================================${NC}"
echo ""

# 1. 检查 Python 版本
echo -e "${YELLOW}[1/6] 检查 Python 环境...${NC}"
if ! command -v python3 &> /dev/null; then
    echo -e "${RED}❌ 未找到 Python3，请先安装 Python 3.9+${NC}"
    exit 1
fi

PYTHON_VERSION=$(python3 -c 'import sys; print(".".join(map(str, sys.version_info[:2])))')
REQUIRED_VERSION="3.9"

if [ "$(printf '%s\n' "$REQUIRED_VERSION" "$PYTHON_VERSION" | sort -V | head -n1)" != "$REQUIRED_VERSION" ]; then
    echo -e "${RED}❌ Python 版本过低（当前 $PYTHON_VERSION，需要 3.9+）${NC}"
    exit 1
fi

echo -e "${GREEN}✅ Python $PYTHON_VERSION${NC}"

# 2. 检查并克隆 wexin-read-mcp
echo ""
echo -e "${YELLOW}[2/6] 安装 MCP 服务器...${NC}"
MCP_DIR="$SKILL_DIR/wexin-read-mcp"

if [ -d "$MCP_DIR" ]; then
    echo -e "${GREEN}✅ MCP 服务器已存在${NC}"
else
    echo "正在克隆 wexin-read-mcp..."
    git clone https://github.com/Bwkyd/wexin-read-mcp.git "$MCP_DIR"
    echo -e "${GREEN}✅ MCP 服务器克隆完成${NC}"
fi

# 3. 安装 Python 依赖
echo ""
echo -e "${YELLOW}[3/6] 安装 Python 依赖...${NC}"

# 安装 MCP 服务器依赖
if [ -f "$MCP_DIR/requirements.txt" ]; then
    echo "安装 MCP 依赖..."
    pip3 install -r "$MCP_DIR/requirements.txt" -q
    echo -e "${GREEN}✅ MCP 依赖安装完成${NC}"
fi

# 安装 Skill 依赖（包括 markitdown）
if [ -f "$SKILL_DIR/requirements.txt" ]; then
    echo "安装 Skill 依赖（包括 markitdown 文件转换工具）..."
    pip3 install -r "$SKILL_DIR/requirements.txt" -q
    echo -e "${GREEN}✅ Skill 依赖安装完成${NC}"
    echo -e "${GREEN}✅ markitdown 已安装（支持 15+ 文件格式转换）${NC}"
fi

# 4. 安装 Playwright 浏览器
echo ""
echo -e "${YELLOW}[4/6] 安装 Playwright 浏览器...${NC}"
echo "这可能需要几分钟，请耐心等待..."

if python3 -c "from playwright.sync_api import sync_playwright" 2>/dev/null; then
    playwright install chromium
    echo -e "${GREEN}✅ Playwright 浏览器安装完成${NC}"
else
    echo -e "${RED}❌ Playwright 导入失败，请检查安装${NC}"
    exit 1
fi

# 5. 检查并安装 notebooklm
echo ""
echo -e "${YELLOW}[5/6] 检查 NotebookLM CLI...${NC}"

if command -v notebooklm &> /dev/null; then
    NOTEBOOKLM_VERSION=$(notebooklm --version 2>/dev/null || echo "unknown")
    echo -e "${GREEN}✅ NotebookLM CLI 已安装 ($NOTEBOOKLM_VERSION)${NC}"
else
    echo "正在安装 notebooklm-py..."
    pip3 install git+https://github.com/teng-lin/notebooklm-py.git -q

    if command -v notebooklm &> /dev/null; then
        echo -e "${GREEN}✅ NotebookLM CLI 安装完成${NC}"
    else
        echo -e "${RED}❌ NotebookLM CLI 安装失败${NC}"
        echo "请手动安装：pip3 install git+https://github.com/teng-lin/notebooklm-py.git"
        exit 1
    fi
fi

# 6. 配置指导
echo ""
echo -e "${YELLOW}[6/6] 配置指导${NC}"
echo ""

CLAUDE_CONFIG="$HOME/.claude/config.json"
CONFIG_SNIPPET="    \"weixin-reader\": {
      \"command\": \"python\",
      \"args\": [
        \"$MCP_DIR/src/server.py\"
      ]
    }"

echo -e "${BLUE}📝 下一步：配置 MCP 服务器${NC}"
echo ""
echo "请编辑 $CLAUDE_CONFIG"
echo ""
echo "在 \"mcpServers\" 中添加："
echo -e "${GREEN}$CONFIG_SNIPPET${NC}"
echo ""
echo "完整配置示例："
echo -e "${GREEN}{
  \"primaryApiKey\": \"any\",
  \"mcpServers\": {
$CONFIG_SNIPPET
  }
}${NC}"
echo ""

# 检查是否已配置
if [ -f "$CLAUDE_CONFIG" ]; then
    if grep -q "weixin-reader" "$CLAUDE_CONFIG"; then
        echo -e "${GREEN}✅ 检测到已有 weixin-reader 配置${NC}"
    else
        echo -e "${YELLOW}⚠️  未检测到 weixin-reader 配置，请手动添加${NC}"
    fi
else
    echo -e "${YELLOW}⚠️  未找到 Claude 配置文件，请手动创建${NC}"
fi

echo ""
echo -e "${BLUE}🔐 NotebookLM 认证${NC}"
echo ""
echo "首次使用前，请运行："
echo -e "${GREEN}  notebooklm login${NC}"
echo -e "${GREEN}  notebooklm list  # 验证认证成功${NC}"
echo ""

# 最终检查
echo ""
echo -e "${BLUE}========================================${NC}"
echo -e "${GREEN}✅ 安装完成！${NC}"
echo -e "${BLUE}========================================${NC}"
echo ""
echo "📦 安装位置：$SKILL_DIR"
echo ""
echo "⚠️  重要提醒："
echo "  1. 配置 MCP 服务器后需要重启 Claude Code"
echo "  2. 首次使用前运行 notebooklm login"
echo ""
echo "🚀 使用示例："
echo "  把这篇文章生成播客 https://mp.weixin.qq.com/s/xxx"
echo ""