fr-cli 2.1.0__py3-none-any.whl

fr_cli/weapon/mail.py

@@ -0,0 +1,227 @@
+"""
+邮差精灵 (IMAP/SMTP)
+"""
+import re
+from html.parser import HTMLParser
+from fr_cli.lang.i18n import T
+
+class _HTMLTextExtractor(HTMLParser):
+    """将 HTML 提取为纯文本 —— 去除标签，保留换行"""
+    def __init__(self):
+        super().__init__()
+        self.text = []
+        self.skip_tags = {"script", "style", "head", "title", "meta", "link"}
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.skip_tags:
+            self._skip_depth += 1
+        elif tag in ("br", "p", "div", "h1", "h2", "h3", "h4", "h5", "h6", "li", "tr"):
+            self.text.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in self.skip_tags:
+            self._skip_depth = max(0, self._skip_depth - 1)
+        elif tag in ("p", "div", "h1", "h2", "h3", "h4", "h5", "h6", "li", "tr", "td"):
+            self.text.append("\n")
+
+    def handle_data(self, data):
+        if self._skip_depth == 0:
+            self.text.append(data)
+
+    def get_text(self):
+        raw = "".join(self.text)
+        # 合并多个连续换行
+        return re.sub(r"\n{3,}", "\n\n", raw).strip()
+
+
+def _html_to_text(html):
+    """HTML → 纯文本"""
+    try:
+        parser = _HTMLTextExtractor()
+        parser.feed(html)
+        return parser.get_text()
+    except Exception:
+        # 兜底：正则去标签
+        return re.sub(r"<[^>]+>", "", html).strip()
+
+class MailClient:
+    def __init__(self, cfg):
+        self.imap_server = cfg.get("imap_server", "")
+        self.smtp_server = cfg.get("smtp_server", "")
+        self.email = cfg.get("email", "")
+        self.password = cfg.get("password", "")
+        self.connected = False
+        
+        # 尝试连接（可选依赖检查）
+        try:
+            import imaplib
+            import smtplib
+            import email
+            from email.mime.text import MIMEText
+            from email.mime.multipart import MIMEMultipart
+            from email.header import decode_header
+            self.imap = imaplib
+            self.smtp = smtplib
+            self.email_module = email
+            self.mime_text = MIMEText
+            self.mime_multipart = MIMEMultipart
+            self.decode_header = decode_header
+            self.connected = True
+        except ImportError:
+            self.connected = False
+
+    def inbox(self, lang):
+        """获取收件箱列表"""
+        if not self.connected:
+            return None, T("mail_no_cfg", lang)
+        if not self.imap_server or not self.email or not self.password:
+            return None, T("mail_no_cfg", lang)
+
+        mail = None
+        try:
+            mail = self.imap.IMAP4_SSL(self.imap_server)
+            mail.login(self.email, self.password)
+            mail.select('inbox')
+
+            _, data = mail.search(None, 'ALL')
+            mail_ids = data[0].split()
+
+            mails = []
+            for mail_id in mail_ids[-10:]:  # 只取最近10封
+                _, msg_data = mail.fetch(mail_id, '(RFC822)')
+                raw_email = msg_data[0][1]
+                email_message = self.email_module.message_from_bytes(raw_email)
+
+                subject = ""
+                for part in self.decode_header(email_message['Subject']):
+                    if isinstance(part[0], bytes):
+                        subject += part[0].decode(part[1] or 'utf-8', errors='ignore')
+                    else:
+                        subject += part[0]
+
+                from_addr = email_message['From'] or "Unknown"
+
+                mails.append({
+                    "id": mail_id.decode(),
+                    "sub": subject[:50],
+                    "from": from_addr[:30]
+                })
+
+            return mails, None
+        except Exception as e:
+            return None, f"{T('mail_err', lang)} {e}"
+        finally:
+            if mail:
+                try:
+                    mail.close()
+                    mail.logout()
+                except Exception:
+                    pass
+
+    def read(self, mail_id, lang):
+        """读取指定邮件"""
+        if not self.connected:
+            return None, T("mail_no_cfg", lang)
+
+        mail = None
+        try:
+            mail = self.imap.IMAP4_SSL(self.imap_server)
+            mail.login(self.email, self.password)
+            mail.select('inbox')
+
+            _, msg_data = mail.fetch(mail_id, '(RFC822)')
+            raw_email = msg_data[0][1]
+            email_message = self.email_module.message_from_bytes(raw_email)
+
+            subject = ""
+            for part in self.decode_header(email_message['Subject']):
+                if isinstance(part[0], bytes):
+                    subject += part[0].decode(part[1] or 'utf-8', errors='ignore')
+                else:
+                    subject += part[0]
+
+            from_addr = email_message['From'] or "Unknown"
+            date = email_message['Date'] or ""
+
+            body = ""
+            html_body = ""
+            if email_message.is_multipart():
+                for part in email_message.walk():
+                    ctype = part.get_content_type()
+                    if ctype == "text/plain":
+                        try:
+                            body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
+                        except Exception:
+                            body = str(part.get_payload())
+                        break
+                    elif ctype == "text/html" and not html_body:
+                        try:
+                            html_body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
+                        except Exception:
+                            html_body = str(part.get_payload())
+                # 如果没有纯文本，从 HTML 中提取
+                if not body and html_body:
+                    body = _html_to_text(html_body)
+            else:
+                ctype = email_message.get_content_type()
+                try:
+                    raw = email_message.get_payload(decode=True).decode('utf-8', errors='ignore')
+                except Exception:
+                    raw = str(email_message.get_payload())
+                if ctype == "text/html":
+                    body = _html_to_text(raw)
+                else:
+                    body = raw
+
+            return {
+                "sub": subject,
+                "from": from_addr,
+                "date": date,
+                "body": body
+            }, None
+        except Exception as e:
+            return None, f"{T('mail_err', lang)} {e}"
+        finally:
+            if mail:
+                try:
+                    mail.close()
+                    mail.logout()
+                except Exception:
+                    pass
+
+    def send(self, to, subject, body, lang):
+        """发送邮件"""
+        if not self.connected:
+            return False, T("mail_no_cfg", lang)
+        if not self.smtp_server or not self.email or not self.password:
+            return False, T("mail_no_cfg", lang)
+
+        # 安全校验：防止邮件头注入
+        import email.utils
+        if '\n' in to or '\r' in to or '\n' in subject or '\r' in subject:
+            return False, "❌ 邮件地址或主题包含非法字符"
+        parsed = email.utils.parseaddr(to)
+        if not parsed[1] or '@' not in parsed[1]:
+            return False, "❌ 收件人地址格式无效"
+
+        server = None
+        try:
+            msg = self.mime_multipart()
+            msg['From'] = self.email
+            msg['To'] = to
+            msg['Subject'] = subject
+
+            server = self.smtp.SMTP_SSL(self.smtp_server, 465)
+            server.login(self.email, self.password)
+            server.send_message(msg)
+
+            return True, None
+        except Exception as e:
+            return False, f"{T('mail_err', lang)} {e}"
+        finally:
+            if server:
+                try:
+                    server.quit()
+                except Exception:
+                    pass

fr_cli/weapon/mcp.py

@@ -0,0 +1,204 @@
+"""
+MCP (Model Context Protocol) 法宝接口
+连接外部 MCP 服务器，将其工具纳入统一注册表。
+支持 stdio 与 sse 两种传输方式。
+"""
+import asyncio
+import json
+from typing import Dict, List, Any, Optional
+
+from fr_cli.ui.ui import CYAN, GREEN, YELLOW, RED, DIM, RESET
+
+try:
+    from mcp import ClientSession, StdioServerParameters
+    from mcp.client.stdio import stdio_client
+    _MCP_AVAILABLE = True
+except ImportError:
+    _MCP_AVAILABLE = False
+
+
+class MCPManager:
+    """MCP 法宝管理器 —— 统御外部神通"""
+
+    def __init__(self, cfg: dict):
+        self.cfg = cfg
+        self._servers = cfg.get("mcp", {}).get("servers", [])
+
+    def _get_server_cfg(self, name: str) -> Optional[dict]:
+        for s in self._servers:
+            if s.get("name") == name:
+                return s
+        return None
+
+    def _save(self):
+        """持久化到本命配置"""
+        self.cfg["mcp"] = {"servers": self._servers}
+        from fr_cli.conf.config import save_config
+        save_config(self.cfg)
+
+    # ── 异步核心 ──
+
+    async def _list_tools_async(self, server_cfg: dict) -> List[dict]:
+        """异步列出单个服务器的法宝"""
+        transport = server_cfg.get("transport", "stdio")
+        tools = []
+
+        if transport == "stdio":
+            params = StdioServerParameters(
+                command=server_cfg["command"],
+                args=server_cfg.get("args", []),
+                env=server_cfg.get("env") or None,
+                cwd=server_cfg.get("cwd") or None,
+            )
+            async with stdio_client(params) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    result = await session.list_tools()
+                    for tool in result.tools:
+                        tools.append({
+                            "name": tool.name,
+                            "description": tool.description or "",
+                            "input_schema": tool.inputSchema,
+                            "server": server_cfg["name"],
+                        })
+        elif transport == "sse":
+            # SSE 传输待后续扩展
+            pass
+        return tools
+
+    async def _call_tool_async(self, server_cfg: dict, tool_name: str, arguments: dict) -> Any:
+        """异步调用法宝"""
+        transport = server_cfg.get("transport", "stdio")
+
+        if transport == "stdio":
+            params = StdioServerParameters(
+                command=server_cfg["command"],
+                args=server_cfg.get("args", []),
+                env=server_cfg.get("env") or None,
+                cwd=server_cfg.get("cwd") or None,
+            )
+            async with stdio_client(params) as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+                    result = await session.call_tool(tool_name, arguments=arguments)
+                    return result
+        elif transport == "sse":
+            raise NotImplementedError("SSE 传输尚未实现")
+        return None
+
+    # ── 同步入口 ──
+
+    def list_servers(self) -> List[dict]:
+        """列出所有已配置的服务器"""
+        return [s.copy() for s in self._servers]
+
+    def _run_with_timeout(self, coro, timeout=10):
+        """带超时的异步执行包装"""
+        async def wrapper():
+            return await asyncio.wait_for(coro, timeout=timeout)
+        try:
+            return asyncio.run(wrapper())
+        except asyncio.TimeoutError:
+            raise TimeoutError("MCP 服务器连接超时")
+
+    def list_all_tools(self) -> List[dict]:
+        """汇聚所有可用服务器的法宝列表"""
+        if not _MCP_AVAILABLE:
+            return []
+        all_tools = []
+        for s in self._servers:
+            if not s.get("enabled", True):
+                continue
+            try:
+                tools = self._run_with_timeout(self._list_tools_async(s), timeout=15)
+                all_tools.extend(tools)
+            except Exception as e:
+                # 单个服务器失败不影响其他
+                pass
+        return all_tools
+
+    def call_tool(self, server_name: str, tool_name: str, arguments: dict) -> tuple:
+        """同步入口：调用 MCP 法宝
+        返回 (result, error)
+        """
+        if not _MCP_AVAILABLE:
+            return None, "MCP SDK 未安装，请执行: pip install mcp"
+
+        server_cfg = self._get_server_cfg(server_name)
+        if not server_cfg:
+            return None, f"MCP 服务器未找到: {server_name}"
+        if not server_cfg.get("enabled", True):
+            return None, f"MCP 服务器已禁用: {server_name}"
+
+        try:
+            result = self._run_with_timeout(self._call_tool_async(server_cfg, tool_name, arguments), timeout=60)
+            if result is None:
+                return None, "MCP 返回空结果"
+
+            if result.isError:
+                content = []
+                for item in result.content:
+                    if hasattr(item, "text"):
+                        content.append(item.text)
+                    else:
+                        content.append(str(item))
+                return None, "MCP 工具执行错误:\n" + "\n".join(content)
+
+            content = []
+            for item in result.content:
+                if hasattr(item, "text"):
+                    content.append(item.text)
+                else:
+                    content.append(str(item))
+            return "\n".join(content), None
+        except Exception as e:
+            return None, f"MCP 调用失败: {e}"
+
+    def add_server(self, name: str, command: str, args: list = None,
+                   env: dict = None, transport: str = "stdio", cwd: str = None) -> tuple:
+        """添加服务器配置"""
+        if self._get_server_cfg(name):
+            return False, f"服务器 {name} 已存在"
+        self._servers.append({
+            "name": name,
+            "transport": transport,
+            "command": command,
+            "args": args or [],
+            "env": env or {},
+            "cwd": cwd,
+            "enabled": True,
+        })
+        self._save()
+        return True, None
+
+    def remove_server(self, name: str) -> tuple:
+        """删除服务器配置"""
+        for i, s in enumerate(self._servers):
+            if s.get("name") == name:
+                self._servers.pop(i)
+                self._save()
+                return True, None
+        return False, f"服务器 {name} 未找到"
+
+    def toggle_server(self, name: str, enabled: bool) -> tuple:
+        """启用/禁用服务器"""
+        s = self._get_server_cfg(name)
+        if not s:
+            return False, f"服务器 {name} 未找到"
+        s["enabled"] = enabled
+        self._save()
+        return True, None
+
+    def get_server_tools_desc(self) -> str:
+        """生成所有 MCP 法宝的描述文本，用于注入 system prompt"""
+        tools = self.list_all_tools()
+        if not tools:
+            return ""
+        lines = ["\n【外部神通 (MCP)】"]
+        for t in tools:
+            lines.append(f"  - {t['name']}: {t['description']}")
+            lines.append(f"    所属服务器: {t['server']}")
+            schema = t.get("input_schema", {})
+            if schema and schema.get("properties"):
+                lines.append(f"    参数: {json.dumps(schema['properties'], ensure_ascii=False)}")
+        return "\n".join(lines)

fr_cli/weapon/vision.py

@@ -0,0 +1,74 @@
+"""
+天眼视觉引擎
+对接智谱 CogView 画图与 GLM-4V 看图能力
+"""
+from fr_cli.lang.i18n import T
+from fr_cli.ui.ui import CYAN, RESET
+import base64, os
+
+def gen_img(client, prompt, out_dir, lang):
+    """
+    调用 CogView 生成图片并保存到本地
+    :return: tuple (是否成功 bool, 本地路径或错误信息 str)
+    """
+    print(f"{CYAN}{T('gen_ing', lang)}{RESET}")
+    try:
+        response = client.images.generations(
+            model="cogview-3-plus", # 使用最新版画图模型
+            prompt=prompt,
+            size="1024x1024"
+        )
+        if response.data and response.data[0].url:
+            # 智谱返回的是临时URL，需下载保存到本地
+            import requests
+            img_url = response.data[0].url
+            res = requests.get(img_url, timeout=15)
+            res.raise_for_status()
+
+            os.makedirs(out_dir, exist_ok=True)
+            safe_name = "".join(c if c.isalnum() or c in ('_', '-') else '_' for c in prompt[:30])
+            local_path = os.path.join(out_dir, f"img_{safe_name}.png")
+            
+            with open(local_path, "wb") as f:
+                f.write(res.content)
+            return True, local_path
+        return False, T("gen_fail", lang) + "No URL"
+    except Exception as e: return False, f"{T('gen_fail', lang)} {e}"
+
+def prep_see_msg(messages, img_path, user_text, vfs=None):
+    """
+    为 GLM-4V 准备带图的上下文 (不直接请求，而是构造好 messages 返回给主循环)
+    :param vfs: VFS 实例，若提供则通过沙盒读取本地文件
+    """
+    msg_content = []
+    # 如果是本地文件，转为 base64
+    # 优先使用 VFS 沙盒路径解析；若无 VFS 则回退到 os.path（测试兼容）
+    is_local = False
+    if vfs is not None:
+        resolved = vfs._resolve(img_path)
+        is_local = resolved is not None and resolved.exists()
+    else:
+        is_local = os.path.exists(img_path)
+
+    if is_local:
+        fh = vfs._resolve(img_path) if vfs is not None else Path(img_path)
+        with open(fh, "rb") as f:
+            b64 = base64.b64encode(f.read()).decode("utf-8")
+        msg_content.append({
+            "type": "image_url",
+            "image_url": {"url": f"data:image/jpeg;base64,{b64}"}
+        })
+    else:
+        # 直接当做 URL 处理
+        msg_content.append({
+            "type": "image_url",
+            "image_url": {"url": img_path}
+        })
+    
+    if user_text:
+        msg_content.append({"type": "text", "text": user_text})
+    else:
+        msg_content.append({"type": "text", "text": "请描述这张图片的内容。"})
+        
+    messages.append({"role": "user", "content": msg_content})
+    return messages

fr_cli/weapon/web.py

@@ -0,0 +1,88 @@
+"""
+互联网游侠
+零配置的网页搜索与正文抽取
+依赖: requests (pip install requests)
+"""
+import re
+import ipaddress
+from urllib.parse import urlparse
+from fr_cli.lang.i18n import T
+try:
+    import requests
+    HAS_REQ = True
+except ImportError:
+    HAS_REQ = False
+
+
+def _is_private_url(url):
+    """SSRF 防护：拦截内网 IP、私有地址和非 HTTP(S) 协议"""
+    try:
+        parsed = urlparse(url)
+        # 只允许 http/https
+        if parsed.scheme not in ("http", "https"):
+            return True
+        hostname = parsed.hostname or ""
+        # 拦截 localhost 类域名
+        if hostname.lower() in ("localhost", "127.0.0.1", "0.0.0.0", "::1"):
+            return True
+        # 尝试解析为 IP
+        try:
+            ip = ipaddress.ip_address(hostname)
+            if ip.is_private or ip.is_loopback or ip.is_reserved or ip.is_multicast or ip.is_link_local:
+                return True
+        except ValueError:
+            pass
+        return False
+    except Exception:
+        return True
+
+class WebRaider:
+    def search(self, q, lang):
+        """使用百度搜索进行零配置搜索"""
+        if not HAS_REQ: return None, "❌ pip install requests"
+        try:
+            import urllib.parse
+            headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
+            # 百度搜索
+            url = f"https://www.baidu.com/s?wd={urllib.parse.quote(q)}"
+            if _is_private_url(url):
+                return None, "❌ 禁止访问该 URL"
+            res = requests.get(url, headers=headers, timeout=8)
+            
+            # 简易正则提取结果
+            results = []
+            
+            # 方法1：匹配任何包含href的a标签和后面的文本
+            blocks = re.findall(r'<a[^>]*href="([^"]+)"[^>]*>([^<]+)</a>', res.text, re.IGNORECASE)
+            for link, title in blocks:
+                clean_title = title.strip()
+                # 过滤掉太短的标题和明显的非结果链接
+                if clean_title and len(clean_title) > 8 and 'baidu.com' not in link:
+                    results.append({"title": clean_title, "url": link, "snippet": "点击查看详情"})
+                    if len(results) >= 5:
+                        break
+            
+            return results[:5], None
+        except Exception as e: return None, f"{T('web_err', lang)} {e}"
+
+    def fetch(self, url, lang):
+        """抓取指定 URL 的网页并提取纯文本"""
+        if not HAS_REQ: return None, "❌ pip install requests"
+        if _is_private_url(url):
+            return None, "❌ 禁止访问该 URL"
+        try:
+            headers = {"User-Agent": "Mozilla/5.0"}
+            res = requests.get(url, headers=headers, timeout=10)
+            res.raise_for_status()
+            
+            # 极简 HTML 标签剥离
+            text = re.sub(r'<script[^>]*>.*?</script>', '', res.text, flags=re.DOTALL | re.IGNORECASE)
+            text = re.sub(r'<style[^>]*>.*?</style>', '', text, flags=re.DOTALL | re.IGNORECASE)
+            text = re.sub(r'<[^>]+>', ' ', text)
+            text = re.sub(r'\s+', ' ', text).strip()
+            
+            # 截断过长的文本
+            if len(text) > 3000:
+                text = text[:3000] + "\n\n...[Truncated]"
+            return text, None
+        except Exception as e: return None, f"{T('web_err', lang)} {e}"