fr-cli 2.1.0__py3-none-any.whl

fr_cli/breakthrough/update.py

@@ -0,0 +1,154 @@
+"""
+自动更新模块 update.py
+接口地址: https://up.seeknew.cn/v1/cliupdate
+"""
+import os, sys, json, platform, subprocess, shutil, tempfile, time, zipfile, hashlib
+from pathlib import Path
+from typing import Callable, Optional, Tuple
+
+UPDATE_API_URL = "https://up.seeknew.cn/v1/cliupdate"
+REQUEST_TIMEOUT = 15
+PROJECT_ROOT = Path(__file__).resolve().parent
+VERSION_FILE = PROJECT_ROOT / "__version__.txt"
+
+def _read_local_version() -> str:
+    try:
+        if VERSION_FILE.is_file():
+            txt = VERSION_FILE.read_text(encoding="utf-8").strip()
+            if txt:
+                first_line = txt.splitlines()[0].strip().lower().lstrip('v')
+                return first_line
+    except Exception: pass
+    # Fallback to package __version__
+    try:
+        from fr_cli import __version__
+        return str(__version__).strip().lower().lstrip('v')
+    except Exception:
+        return "0.0.0"
+
+def _save_local_version(version: str) -> None:
+    try: VERSION_FILE.write_text(str(version).strip() + "\n", encoding="utf-8")
+    except Exception: pass
+
+def _parse_version_tuple(v: str) -> Tuple[int, ...]:
+    parts = v.replace("-", ".").split(".")
+    nums = []
+    for p in parts:
+        p = p.strip(); num = 0
+        if p and p[0].isdigit():
+            i = 0
+            while i < len(p) and p[i].isdigit(): i += 1
+            num = int(p[:i])
+        nums.append(num)
+    while len(nums) < 3: nums.append(0)
+    return tuple(nums[:3])
+
+def _is_newer(remote: str, local: str) -> bool:
+    return _parse_version_tuple(remote) > _parse_version_tuple(local)
+
+def _fetch_info() -> Tuple[Optional[dict], Optional[str]]:
+    try:
+        import urllib.request, ssl
+        ctx = ssl.create_default_context()
+        req = urllib.request.Request(UPDATE_API_URL, method="GET", headers={
+            "Accept": "application/json", "User-Agent": f"cli-update/{platform.system()}"
+        })
+        with urllib.request.urlopen(req, timeout=REQUEST_TIMEOUT, context=ctx) as resp:
+            data = json.loads(resp.read().decode("utf-8", errors="ignore"))
+            if isinstance(data, dict) and "version" in data and "download_url" in data: return data, None
+            if isinstance(data, dict) and "data" in data and isinstance(data["data"], dict):
+                inner = data["data"]
+                if "version" in inner and "download_url" in inner: return inner, None
+            return None, "Unrecognized schema."
+    except Exception as e: return None, str(e)
+
+def _download(url: str) -> Tuple[Optional[bytes], Optional[str]]:
+    try:
+        import urllib.request, ssl
+        req = urllib.request.Request(url, headers={"User-Agent": "cli-update/1.0"})
+        with urllib.request.urlopen(req, timeout=120, context=ssl.create_default_context()) as resp:
+            data = resp.read()
+            return (data, None) if data else (None, "Empty payload.")
+    except Exception as e: return None, str(e)
+
+def _apply_source_zip(zip_bytes: bytes, root: Path) -> Tuple[bool, str]:
+    try:
+        with tempfile.TemporaryDirectory() as tmp:
+            zpath = Path(tmp) / "u.zip"; zpath.write_bytes(zip_bytes)
+            ext = Path(tmp) / "ext"
+            with zipfile.ZipFile(zpath, 'r') as zf: zf.extractall(ext)
+            
+            safe_exts = {".py",".sh",".bat",".md",".txt",".toml",".yaml",".yml",".html",".css",".js",".png",".jpg",".gif"}
+            skip = {"__version__.txt", "__config__.json"}
+            skip_dirs = {"data", "logs", "__pycache__", ".git", ".idea"}
+            
+            for r, dirs, files in os.walk(ext):
+                rp = Path(r).relative_to(ext)
+                if any(p in skip_dirs for p in rp.parts): continue
+                for n in files:
+                    s = Path(r) / n; d = root / rp / n
+                    if n in skip or n.startswith(".") or d.suffix.lower() not in safe_exts: continue
+                    try:
+                        d.parent.mkdir(parents=True, exist_ok=True)
+                        if d.exists():
+                            shutil.copy2(str(d), str(d.with_suffix(d.suffix+".bak")))
+                        shutil.copy2(str(s), str(d))
+                    except Exception: pass
+            return True, "OK"
+    except Exception as e: return False, str(e)
+
+def update_check(local_version: Optional[str] = None, verbose: bool = False) -> Tuple[bool, Optional[dict], Optional[str]]:
+    lv = local_version or _read_local_version()
+    if verbose: print(f"[Update] Local: {lv}")
+    info, err = _fetch_info()
+    if err: return False, None, err
+    rv = info.get("version", "0.0.0")
+    if verbose: print(f"[Update] Remote: {rv}")
+    return _is_newer(rv, lv), info, None
+
+def update_and_restart(local_version: Optional[str] = None, verbose: bool = False, allow_restart: bool = True, on_before_restart: Optional[Callable] = None) -> Tuple[bool, str]:
+    has, info, err = update_check(local_version, verbose)
+    if err: return False, err
+    if not has or not info: return False, "Already up to date."
+    
+    data, err = _download(info.get("download_url", ""))
+    if err or not data: return False, err or "Download failed."
+    
+    sha_exp = info.get("sha256")
+    if sha_exp and hashlib.sha256(data).hexdigest().lower() != sha_exp.lower():
+        return False, "SHA256 mismatch."
+        
+    ftype = info.get("file_type", "source_zip")
+    nver = info.get("version", "")
+    
+    if ftype == "source_zip":
+        ok, msg = _apply_source_zip(data, PROJECT_ROOT)
+        if not ok: return False, msg
+        _save_local_version(nver)
+        if allow_restart:
+            if on_before_restart: on_before_restart()
+            subprocess.Popen([sys.executable, str(PROJECT_ROOT / "main.py")], cwd=str(PROJECT_ROOT))
+            time.sleep(0.5)
+            sys.stdout.flush()
+            sys.stderr.flush()
+            sys.exit(0)
+        return True, f"Updated to {nver}. Please restart."
+    else:
+        fname = os.path.basename(info.get("download_url", "update.bin"))
+        (PROJECT_ROOT / fname).write_bytes(data)
+        return True, f"Saved {fname}. Please update manually."
+
+def cli_entry(args=None):
+    args = args or sys.argv[1:]
+    if not args or args[0].lower() == "check":
+        ok, info, err = update_check(verbose=True)
+        if err: print(f"Check failed: {err}"); return 1
+        if not ok: print("Already up to date."); return 0
+        print(f"New version: {info.get('version')}\nNote: {info.get('release_note', '')}"); return 0
+    elif args[0].lower() == "run":
+        ok, msg = update_and_restart(verbose=True)
+        print(f"{'Success' if ok else 'Failed'}: {msg}"); return 0 if ok else 1
+    else:
+        print("Usage: python update.py check | run"); return 2
+
+if __name__ == "__main__": sys.exit(cli_entry())

fr_cli/command/__init__.py

@@ -0,0 +1,4 @@
+"""
+命令执行子系统
+包含安全确认管理器与命令执行引擎
+"""

fr_cli/command/executor.py

@@ -0,0 +1,276 @@
+"""
+命令执行引擎
+负责解析 AI 响应中的调用标记，并调度到统一注册表执行。
+"""
+import re
+import json
+import ast
+from types import SimpleNamespace
+from fr_cli.command.registry import get_registry
+from fr_cli.addon.plugin import exec_plugin
+
+
+def _build_deps(state):
+    """根据 AppState 动态构建依赖命名空间（每次调用实时反射，避免快照过时）"""
+    return SimpleNamespace(
+        vfs=state.vfs,
+        mail_c=state.mail_c,
+        web_c=state.web_c,
+        disk_c=state.disk_c,
+        plugins=state.plugins,
+        lang=state.lang,
+        security=state.security,
+        cfg=state.cfg,
+        client=state.client,
+        model_name=state.model_name,
+        mcp=getattr(state, "mcp", None),
+    )
+
+
+class CommandExecutor:
+    """
+    命令执行器：解析 AI 回复中的调用标记，并通过注册表统一调度执行。
+    直接持有 AppState，每次调用时动态构建依赖快照，彻底消除状态过时问题。
+
+    公共接口（保持向后兼容）：
+      - invoke_tool(tool_name, kwargs, msgs=None): 结构化工具调用
+      - execute(cmd_str, msgs=None): 命令字符串调用
+      - process_ai_commands(ai_response, msgs=None): 解析并执行 AI 回复中的命令标记
+    """
+
+    def __init__(self, state):
+        self.state = state
+        self._reg = get_registry()
+
+    # ------------------------------------------------------------------
+    # 第一层：结构化工具调用
+    # ------------------------------------------------------------------
+    def invoke_tool(self, tool_name, kwargs, msgs=None):
+        """根据工具名和结构化参数，通过注册表调度执行。返回 (result, error)"""
+        return self._reg.dispatch(_build_deps(self.state), tool_name, msgs=msgs, **kwargs)
+
+    # ------------------------------------------------------------------
+    # 第二层：传统命令解析（用户输入 / 插件调用）
+    # ------------------------------------------------------------------
+    def execute(self, cmd_str, msgs=None):
+        """执行单个命令并返回结果 (result, error)
+        已分词检查插件后，直接通过注册表内部接口调度，避免重复 split。"""
+        parts = cmd_str.strip().split()
+        if not parts:
+            return None, "Empty command"
+        cmd = parts[0].lstrip("/")
+        # 插件命令优先直接处理（保持 mock 路径兼容）
+        if cmd in self.state.plugins:
+            p_args = ' '.join(parts[1:]) if len(parts) > 1 else ""
+            exec_plugin(cmd, self.state.plugins[cmd], p_args, self.state.lang)
+            return f"Plugin {cmd} executed", None
+        # 其余命令通过注册表内部接口直接调度，避免 dispatch_cmd 再次 split
+        return self._reg._dispatch_cmd_parts(_build_deps(self.state), parts, msgs=msgs)
+
+    # ------------------------------------------------------------------
+    # 第三层：AI 回复解析
+    # ------------------------------------------------------------------
+    def _loose_parse_kwargs(self, arg_str):
+        """宽松解析 JSON 参数字符串（回退方案）"""
+        key_pattern = r'"(\w+)"\s*:\s*'
+        keys = list(re.finditer(key_pattern, arg_str))
+        if not keys:
+            return None
+        result = {}
+        for i, m in enumerate(keys):
+            key = m.group(1)
+            start = m.end()
+            if i + 1 < len(keys):
+                end = keys[i + 1].start()
+            else:
+                end = len(arg_str)
+                while end > 0 and arg_str[end - 1] in ' \t\n\r}':
+                    end -= 1
+            val_str = arg_str[start:end].strip().rstrip(',').strip()
+
+            # 布尔值
+            if val_str == 'true':
+                result[key] = True
+                continue
+            if val_str == 'false':
+                result[key] = False
+                continue
+            if val_str == 'null':
+                result[key] = None
+                continue
+            # 数字
+            try:
+                if '.' in val_str:
+                    result[key] = float(val_str)
+                else:
+                    result[key] = int(val_str)
+                continue
+            except ValueError:
+                pass
+            # 字符串（去掉两端引号）
+            if val_str.startswith('"') and val_str.endswith('"'):
+                val_str = val_str[1:-1]
+            # 还原转义序列
+            QUOTE_PH = '\x00Q\x00'
+            val_str = val_str.replace('\\"', QUOTE_PH)
+            val_str = val_str.replace('\\\\', '\\')
+            val_str = val_str.replace('\\n', '\n')
+            val_str = val_str.replace('\\t', '\t')
+            val_str = val_str.replace('\\r', '\r')
+            val_str = val_str.replace(QUOTE_PH, '"')
+            result[key] = val_str
+        return result if result is not None else None
+
+    def _parse_tool_kwargs(self, arg_str):
+        """安全解析工具参数字符串（JSON 或 Python dict）"""
+        arg_str = arg_str.strip()
+        if not arg_str:
+            return {}
+
+        # 预处理：将 JSON 字符串值内的原始换行替换为 \n 转义序列
+        fixed = ""
+        in_string = False
+        escape = False
+        for ch in arg_str:
+            if escape:
+                fixed += ch
+                escape = False
+                continue
+            if ch == '\\':
+                fixed += ch
+                escape = True
+                continue
+            if ch == '"':
+                in_string = not in_string
+                fixed += ch
+                continue
+            if ch in '\n\r' and in_string:
+                fixed += '\\n'
+                continue
+            fixed += ch
+
+        try:
+            return json.loads(fixed)
+        except json.JSONDecodeError:
+            try:
+                return ast.literal_eval(arg_str)
+            except (ValueError, SyntaxError):
+                return self._loose_parse_kwargs(arg_str)
+
+    def _extract_tool_calls(self, text):
+        """从文本中提取所有【调用：tool_name({...})】标记（支持嵌套括号，忽略字符串内的括号）"""
+        calls = []
+        i = 0
+        while True:
+            start = text.find('【调用：', i)
+            if start == -1:
+                break
+            paren = text.find('(', start)
+            if paren == -1:
+                break
+            tool_name = text[start + 4:paren].strip()
+            depth = 1
+            j = paren + 1
+            in_string = False
+            escape = False
+            while j < len(text) and depth > 0:
+                ch = text[j]
+                if escape:
+                    escape = False
+                elif ch == '\\':
+                    escape = True
+                elif ch == '"':
+                    in_string = not in_string
+                elif not in_string:
+                    if ch == '(':
+                        depth += 1
+                    elif ch == ')':
+                        depth -= 1
+                j += 1
+            if depth != 0:
+                i = paren + 1
+                continue
+            arg_str = text[paren + 1:j - 1]
+            end = text.find('】', j - 1)
+            if end == -1:
+                break
+            marker = text[start:end + 1]
+            calls.append((tool_name, arg_str, marker))
+            i = end + 1
+        return calls
+
+    def process_ai_commands(self, ai_response, msgs=None):
+        """
+        解析AI响应中的调用标记并自动执行
+        支持三种格式：
+          1. 【调用：tool_name({"参数": "值"})】（结构化调用）
+          2. 【命令：/command args】（插件 / 兼容命令）
+          3. file_operations/xxx（兼容旧模型输出）
+        返回 (clean_response, cmd_results)
+        """
+        results = []
+        markers_to_remove = []
+
+        # ===== 格式1：【调用：...】 =====
+        for tool_name, arg_str, marker in self._extract_tool_calls(ai_response):
+            kwargs = self._parse_tool_kwargs(arg_str)
+            if kwargs is None:
+                results.append(f"❌ 参数解析失败: {tool_name}\n   原始参数: {arg_str}")
+                markers_to_remove.append(marker)
+                continue
+            result, error = self.invoke_tool(tool_name, kwargs, msgs)
+            if error:
+                results.append(f"❌ 工具调用失败: {tool_name}\n   {error}")
+            else:
+                results.append(f"✅ 工具调用成功: {tool_name}\n   结果: {result}")
+            markers_to_remove.append(marker)
+
+        # ===== 格式2：【命令：...】 =====
+        pattern_cmd = r'【命令：(.*?)】'
+        for m in re.finditer(pattern_cmd, ai_response):
+            cmd_str = m.group(1).strip()
+            marker = m.group(0)
+            result, error = self.execute(cmd_str, msgs)
+            if error:
+                results.append(f"❌ 命令执行失败: {cmd_str}\n   {error}")
+            else:
+                results.append(f"✅ 命令执行成功: {cmd_str}\n   结果: {result}")
+            markers_to_remove.append(marker)
+
+        # ===== 格式3：file_operations/xxx（兼容） =====
+        pattern2_quoted = r'file_operations\s*/(\w+)\s+(\S+)\s+"([\s\S]*?)"'
+        pattern2_plain = r'file_operations\s*/(\w+)\s+(.+)$'
+        for m in re.finditer(pattern2_quoted, ai_response):
+            action = m.group(1)
+            path = m.group(2)
+            content = m.group(3)
+            cmd_str = f"/{action} {path} {content}"
+            result, error = self.execute(cmd_str, msgs)
+            if error:
+                results.append(f"❌ 命令执行失败: {cmd_str}\n   {error}")
+            else:
+                results.append(f"✅ 命令执行成功: {cmd_str}\n   结果: {result}")
+            markers_to_remove.append(m.group(0))
+        for m in re.finditer(pattern2_plain, ai_response, re.MULTILINE):
+            action = m.group(1)
+            args = m.group(2).strip()
+            if args.startswith('"') and args.endswith('"'):
+                args = args[1:-1]
+            already = any(m.group(0) in mk for mk in markers_to_remove)
+            if already:
+                continue
+            cmd_str = f"/{action} {args}"
+            result, error = self.execute(cmd_str, msgs)
+            if error:
+                results.append(f"❌ 命令执行失败: {cmd_str}\n   {error}")
+            else:
+                results.append(f"✅ 命令执行成功: {cmd_str}\n   结果: {result}")
+            markers_to_remove.append(m.group(0))
+
+        # 清理回复文本：移除命令标记后，仅压缩因移除标记产生的连续多余空行，并去除首尾空白
+        clean_response = ai_response
+        for marker in markers_to_remove:
+            clean_response = clean_response.replace(marker, "")
+        clean_response = re.sub(r'\n\s*\n\s*\n+', '\n\n', clean_response).strip()
+
+        return clean_response, results