fr-cli 2.1.0__py3-none-any.whl

fr_cli/security/security.py

@@ -0,0 +1,46 @@
+"""
+四阶安全确认引擎
+"""
+import os
+from fr_cli.ui.ui import RED, BOLD, YELLOW, CYAN, RESET
+from fr_cli.lang.i18n import T
+from fr_cli.conf.config import save_config
+
+def ask(k, d, l, fconfirm, sconfirm, config):
+    """
+    安全询问逻辑
+    :param k: 操作类型键名 (如 sec_read, sec_exec)
+    :param d: 具体操作描述 (如文件名或命令)
+    :param l: 当前语言
+    :param fconfirm: 永久放行状态
+    :param sconfirm: 本次轮回放行状态
+    :param config: 配置字典对象 (用于持久化永久放行状态)
+    :return: tuple (是否放行:bool, 更新后的sconfirm:bool, 更新后的fconfirm:bool)
+    """
+    # 如果已经处于放行状态，直接放行
+    if fconfirm or sconfirm:
+        return True, sconfirm, fconfirm
+
+    # 非交互环境（如 Agent HTTP 服务、CI）默认拒绝，避免阻塞或崩溃
+    if os.environ.get("FR_CLI_NON_INTERACTIVE"):
+        return False, sconfirm, fconfirm
+
+    print(f"\n{RED}{BOLD}{T('sec_title', l)}{RESET}")
+    print(f"{YELLOW}  >> {T(k, l)}: {d}{RESET}")
+    print(f"    {CYAN}{T('sec_opt_y', l)}  {T('sec_opt_a', l)}  {T('sec_opt_f', l)}  {T('sec_opt_n', l)}{RESET}")
+
+    while True:
+        c = input(f"{BOLD}    👉 {RESET}").strip().lower()
+        if c == 'y':
+            return True, sconfirm, fconfirm
+        elif c == 'a':
+            return True, True, fconfirm
+        elif c == 'f':
+            # 永久放行，写入配置文件
+            sconfirm = True
+            fconfirm = True
+            config["auto_confirm_forever"] = True
+            save_config(config)
+            return True, sconfirm, fconfirm
+        elif c == 'n' or c == '':
+            return False, sconfirm, fconfirm

fr_cli/ui/ui.py

@@ -0,0 +1,116 @@
+"""
+终端UI、颜色定义与动画引擎
+"""
+import sys, time, platform, os
+
+# ANSI 颜色与样式常量
+RESET = '\033[0m'; BOLD = '\033[1m'; DIM = '\033[2m'
+RED = '\033[91m'; GREEN = '\033[92m'; YELLOW = '\033[93m'
+BLUE = '\033[94m'; MAGENTA = '\033[95m'; CYAN = '\033[96m'; WHITE = '\033[97m'
+CODE_BG = '\033[48;5;236m'; CODE_FG = '\033[38;5;255m'
+
+# 动画用的字符集
+C_HALF = r"!@#$%^&*()_+-=[]{}|;:<>?/~0123456789ABCDEFabcdef"
+
+def enable_win_ansi():
+    """在 Windows 上启用 ANSI 转义序列支持 (VT100)"""
+    if platform.system() == "Windows":
+        try:
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            handle = kernel32.GetStdHandle(-11)
+            mode = ctypes.c_ulong()
+            kernel32.GetConsoleMode(handle, ctypes.byref(mode))
+            kernel32.SetConsoleMode(handle, mode.value | 0x0004)
+        except Exception:
+            os.system("")
+
+def safe_clear():
+    """安全地清除当前行"""
+    sys.stdout.write("\r\033[K")
+    sys.stdout.flush()
+
+def is_wide(c):
+    """判断字符是否为全角字符（用于动画对齐）"""
+    return len(c.encode('utf-8')) > 1
+
+def get_display_width(text):
+    """计算字符串的实际显示宽度，考虑ANSI颜色代码和全角字符"""
+    import re
+    # 移除ANSI颜色代码
+    clean_text = re.sub(r'\033\[[0-9;]*m', '', text)
+    # 计算显示宽度
+    width = 0
+    for char in clean_text:
+        if is_wide(char):
+            width += 2
+        else:
+            width += 1
+    return width
+
+def print_banner(mn, tl, ad, sn, l):
+    """打印启动时的小乌龟从左向右爬行动画"""
+
+    # 乌龟身体（6行）
+    turtle_body = [
+        '      _____',
+        "   .-' o o '-.",
+        '  /           \\',
+        ' |     ___     |',
+        '  \\   /   \\   /',
+        "   `-._____.-'",
+    ]
+
+    # 三帧腿部姿态（每帧2行腿部）
+    turtle_frames = [
+        turtle_body + ['    /  \\   /  \\ ', '   /    \\ /    \\'],
+        turtle_body + ['    |  |   |  |  ', '   /    \\ /    \\'],
+        turtle_body + ['    \\  /   \\  / ', '   /    \\ /    \\'],
+    ]
+
+    total_lines = len(turtle_frames[0])  # 8 行
+
+    # 爬行路径：从左到右，共 8 个位置，每步 3 格
+    positions = [0, 3, 6, 9, 12, 15, 18, 21]
+
+    # 打印初始空白占位
+    print("\n" * total_lines)
+
+    # 爬行动画：每个位置循环三帧腿部
+    for pos in positions:
+        for frame in turtle_frames:
+            sys.stdout.write(f"\033[{total_lines}A")
+            for line in frame:
+                # 整体右移 pos 格，加绿色
+                padded = " " * pos + line
+                sys.stdout.write(f"\033[K{GREEN}{padded}{RESET}\n")
+            sys.stdout.flush()
+            time.sleep(0.15)
+
+    # 最终定格：再显示一帧（停顿一下）
+    sys.stdout.write(f"\033[{total_lines}A")
+    for line in turtle_frames[0]:
+        padded = " " * positions[-1] + line
+        sys.stdout.write(f"\033[K{GREEN}{padded}{RESET}\n")
+    sys.stdout.flush()
+    time.sleep(0.3)
+
+    # 显示标题
+    if l == "zh":
+        print(f"\n{CYAN}{BOLD}  凡 人 打 字 机 {RESET}")
+        print(f"  【 修 仙 者 的 编 码 引 擎 】\n")
+    else:
+        print(f"\n{CYAN}{BOLD}  F A N R E N  C L I  T O O L{RESET}")
+        print(f"  [ Advanced Code Engine v1.0 ]\n")
+
+    uf = (l == "zh")
+    ds = f"{GREEN}{ad}{RESET}" if ad else f"{RED}{('未开放洞府' if uf else 'No dir')}{RESET}"
+    ss = f"{MAGENTA}{sn}{RESET}" if sn else f"{DIM}{'全新轮回' if uf else 'New'}{RESET}"
+    i1 = f"  {'🔮 模型' if uf else 'Model'}: {GREEN}{BOLD}{mn}{RESET}  |  {'🛡️ 上限' if uf else 'Limit'}: {YELLOW}{tl}{RESET}"
+    i2 = f"  {'📂 洞府' if uf else 'Dir'}: {ds}  |  {'⏳ 轮回' if uf else 'Sess'}: {ss}"
+    bl = max(get_display_width(i1), get_display_width(i2)) + 4
+    print(f"{MAGENTA}┌{'─'*bl}┐{RESET}\n{MAGENTA}│{RESET}{i1}{' '*(bl-get_display_width(i1)-2)}{MAGENTA}│{RESET}\n{MAGENTA}│{RESET}{i2}{' '*(bl-get_display_width(i2)-2)}{MAGENTA}│{RESET}\n{MAGENTA}└{'─'*bl}┘{RESET}\n")
+
+def print_bye():
+    """打印退出动画"""
+    print(f"\n{DIM}欢 迎 下 次 继 续 修 仙{RESET}\n")

fr_cli/weapon/cron.py

@@ -0,0 +1,217 @@
+"""
+结界定时引擎
+使用线程实现轻量级的后台定时任务
+支持 shell 命令和 Agent 分身两种任务类型
+"""
+import threading
+import subprocess
+import shlex
+from fr_cli.ui.ui import RED, GREEN, DIM, YELLOW, RESET
+from fr_cli.lang.i18n import T
+
+
+class CronManager:
+    """定时任务管理器 —— 结界掌控者"""
+
+    def __init__(self):
+        self.jobs = []
+        self._job_id_counter = 0
+        self._lock = threading.Lock()
+
+    def _job_runner(self, job_id, cmd, interval, lang, job_type="shell", agent_name=None, agent_input="", state=None):
+        """内部递归执行器，实现每隔 interval 秒执行一次"""
+        with self._lock:
+            job = next((j for j in self.jobs if j["id"] == job_id), None)
+        if not job:
+            return
+
+        try:
+            if job_type == "agent" and agent_name:
+                # 执行 Agent 分身
+                if state is None:
+                    print(f"{RED}[Cron {job_id}] Error: Agent 任务需要 AppState{RESET}")
+                else:
+                    from fr_cli.agent.executor import run_agent
+                    result, err = run_agent(agent_name, state, user_input=agent_input)
+                    out = (result or "")[:200]
+                    if err:
+                        out = f"Error: {err}"
+                    print(f"{DIM}[Cron {job_id}] Agent[{agent_name}]{RESET} {out}")
+            else:
+                # 执行 shell 命令（安全：不使用 shell=True）
+                try:
+                    cmd_list = shlex.split(cmd)
+                except ValueError:
+                    cmd_list = [cmd]
+                res = subprocess.run(cmd_list, shell=False, capture_output=True, text=True, timeout=30)
+                out = res.stdout.strip()[:100]  # 截断输出
+                print(f"{DIM}[Cron {job_id}]{RESET} {out}")
+        except Exception as e:
+            print(f"{RED}[Cron {job_id}] Error: {e}{RESET}")
+
+        # 重新注册定时器
+        job["timer"] = threading.Timer(
+            interval, self._job_runner,
+            args=(job_id, cmd, interval, lang),
+            kwargs={"job_type": job_type, "agent_name": agent_name, "agent_input": agent_input, "state": state}
+        )
+        job["timer"].daemon = True
+        job["timer"].start()
+
+    def add_job(self, cmd, interval, lang, job_type="shell", agent_name=None, agent_input="", state=None):
+        """添加一个定时循环任务
+
+        Args:
+            cmd: 命令字符串（shell 类型）或 Agent 名称（agent 类型）
+            interval: 执行间隔（秒）
+            lang: 界面语言
+            job_type: "shell" 或 "agent"
+            agent_name: Agent 分身名称（agent 类型时有效）
+            agent_input: 传递给 Agent 的输入内容（agent 类型时有效）
+            state: AppState 实例（agent 类型时必需）
+        """
+        try:
+            interval = float(interval)
+        except ValueError:
+            return None, f"{RED}Invalid seconds{RESET}"
+
+        if interval < 5:
+            return None, f"{RED}间隔不能小于 5 秒{RESET}"
+
+        with self._lock:
+            self._job_id_counter += 1
+            job_id = self._job_id_counter
+
+            job = {
+                "id": job_id,
+                "cmd": cmd,
+                "interval": interval,
+                "timer": None,
+                "job_type": job_type,
+                "agent_name": agent_name,
+                "agent_input": agent_input,
+            }
+            self.jobs.append(job)
+
+        # 启动首次任务
+        job["timer"] = threading.Timer(
+            interval, self._job_runner,
+            args=(job_id, cmd, interval, lang),
+            kwargs={"job_type": job_type, "agent_name": agent_name, "agent_input": agent_input, "state": state}
+        )
+        job["timer"].daemon = True
+        job["timer"].start()
+
+        return job_id, T("cron_ok", lang, job_id, interval)
+
+    def list_jobs(self, lang):
+        """列出当前运行中的任务"""
+        with self._lock:
+            jobs_copy = list(self.jobs)
+        if not jobs_copy:
+            return None, T("empty", lang)
+        res = []
+        for j in jobs_copy:
+            jtype = j.get("job_type", "shell")
+            type_tag = f"[{jtype}]" if jtype == "agent" else "[shell]"
+            target = j.get("agent_name", j["cmd"]) if jtype == "agent" else j["cmd"]
+            res.append(f"{GREEN}ID:{j['id']}{RESET} | {type_tag} | {YELLOW}{j['interval']}s{RESET} | {target[:30]}")
+        return res, None
+
+    def del_job(self, job_id, lang):
+        """根据 ID 终止定时任务"""
+        with self._lock:
+            job = next((j for j in self.jobs if j["id"] == job_id), None)
+            if not job:
+                return False, f"{RED}Not found{RESET}"
+            if job["timer"]:
+                job["timer"].cancel()
+            self.jobs.remove(job)
+        return True, T("cron_killed", lang, job_id)
+
+    def sync_jobs(self, job_configs, lang="zh", state=None):
+        """同步任务列表：根据配置增删任务，保持当前任务与配置一致
+
+        Args:
+            job_configs: 任务配置列表，每项为 dict，包含 cmd/interval/job_type/agent_name/agent_input
+            lang: 界面语言
+            state: AppState 实例（agent 类型任务必需）
+        """
+        with self._lock:
+            current_ids = {j["id"] for j in self.jobs}
+            target_ids = {j.get("id") for j in job_configs if j.get("id")}
+
+            # 删除不在配置中的任务
+            for j in list(self.jobs):
+                if j["id"] not in target_ids:
+                    if j["timer"]:
+                        j["timer"].cancel()
+                    self.jobs.remove(j)
+
+        # 添加配置中有但当前没有的任务（在锁外调用 add_job，避免死锁）
+        for cfg in job_configs:
+            jid = cfg.get("id")
+            if jid and jid not in current_ids:
+                self.add_job(
+                    cmd=cfg.get("cmd", ""),
+                    interval=cfg.get("interval", 60),
+                    lang=lang,
+                    job_type=cfg.get("job_type", "shell"),
+                    agent_name=cfg.get("agent_name"),
+                    agent_input=cfg.get("agent_input", ""),
+                    state=state,
+                )
+
+    def export_jobs(self):
+        """导出所有定时任务为可持久化的字典列表（不含线程对象）"""
+        with self._lock:
+            jobs_copy = list(self.jobs)
+        return [
+            {
+                "id": j["id"],
+                "cmd": j["cmd"],
+                "interval": j["interval"],
+                "job_type": j.get("job_type", "shell"),
+                "agent_name": j.get("agent_name"),
+                "agent_input": j.get("agent_input", ""),
+            }
+            for j in jobs_copy
+        ]
+
+    def import_jobs(self, jobs, lang="zh", state=None):
+        """从字典列表恢复定时任务"""
+        for job in jobs:
+            try:
+                self.add_job(
+                    cmd=job.get("cmd", ""),
+                    interval=job.get("interval", 60),
+                    lang=lang,
+                    job_type=job.get("job_type", "shell"),
+                    agent_name=job.get("agent_name"),
+                    agent_input=job.get("agent_input", ""),
+                    state=state,
+                )
+            except Exception:
+                pass
+
+
+# ------------------------------------------------------------------
+# 默认全局实例（保持向后兼容）
+# ------------------------------------------------------------------
+_default_manager = CronManager()
+JOBS = _default_manager.jobs
+
+
+def add_job(cmd, interval, lang):
+    """添加定时任务（委托给默认管理器）"""
+    return _default_manager.add_job(cmd, interval, lang)
+
+
+def list_jobs(lang):
+    """列出定时任务（委托给默认管理器）"""
+    return _default_manager.list_jobs(lang)
+
+
+def del_job(job_id, lang):
+    """删除定时任务（委托给默认管理器）"""
+    return _default_manager.del_job(job_id, lang)

fr_cli/weapon/dataframe.py

@@ -0,0 +1,97 @@
+"""
+数据卷轴读取器 —— Excel / CSV 分析神通
+支持读取表格文件并提交给大模型进行智能分析。
+"""
+
+def _try_import_pandas():
+    try:
+        import pandas as pd
+        return pd
+    except ImportError:
+        return None
+
+
+def read_excel(path, max_rows=1000, lang="zh"):
+    """读取 Excel 文件，返回文本摘要"""
+    pd = _try_import_pandas()
+    if not pd:
+        return None, "缺少 pandas/openpyxl (pip install pandas openpyxl)"
+    try:
+        df = pd.read_excel(path, nrows=max_rows)
+        return _df_to_summary(df, path, lang), None
+    except Exception as e:
+        return None, str(e)
+
+
+def read_csv(path, max_rows=1000, lang="zh"):
+    """读取 CSV 文件，返回文本摘要"""
+    pd = _try_import_pandas()
+    if not pd:
+        return None, "缺少 pandas (pip install pandas)"
+    try:
+        df = pd.read_csv(path, nrows=max_rows)
+        return _df_to_summary(df, path, lang), None
+    except Exception as e:
+        return None, str(e)
+
+
+def _df_to_summary(df, path, lang):
+    """将 DataFrame 转换为文本摘要，供 LLM 分析"""
+    lines = []
+    lines.append(f"文件: {path}")
+    lines.append(f"总行数: {len(df)}")
+    lines.append(f"总列数: {len(df.columns)}")
+    lines.append(f"列名: {list(df.columns)}")
+    lines.append("")
+    lines.append("数据类型:")
+    for col in df.columns:
+        dtype = str(df[col].dtype)
+        non_null = df[col].notna().sum()
+        unique = df[col].nunique()
+        lines.append(f"  {col}: {dtype} | 非空: {non_null} | 唯一值: {unique}")
+    lines.append("")
+    lines.append("前10行预览:")
+    lines.append(df.head(10).to_string(index=False))
+    lines.append("")
+    lines.append("数值列统计:")
+    try:
+        desc = df.describe().to_string()
+        lines.append(desc)
+    except Exception:
+        pass
+    return "\n".join(lines)
+
+
+def analyze_dataframe(path, query, client, model, lang="zh"):
+    """读取表格并提交给大模型分析"""
+    pd = _try_import_pandas()
+    if not pd:
+        return None, "缺少 pandas"
+
+    # 根据扩展名判断类型
+    ext = str(path).lower().split(".")[-1] if "." in str(path) else ""
+    if ext in ("xlsx", "xls"):
+        summary, err = read_excel(path, lang=lang)
+    elif ext in ("csv",):
+        summary, err = read_csv(path, lang=lang)
+    else:
+        # 尝试两种
+        summary, err = read_csv(path, lang=lang)
+        if err:
+            summary, err = read_excel(path, lang=lang)
+
+    if err:
+        return None, err
+
+    prompt = f"""你是一个数据分析专家。请根据以下表格数据和用户问题进行分析。
+
+{summary}
+
+用户问题: {query}
+
+请用中文给出清晰、简洁的分析结果。如果涉及计算，请展示计算过程。
+"""
+    from fr_cli.core.stream import stream_cnt
+    messages = [{"role": "user", "content": prompt}]
+    result, _, _ = stream_cnt(client, model, messages, lang, custom_prefix="", max_tokens=4096)
+    return result, None

fr_cli/weapon/disk.py

@@ -0,0 +1,141 @@
+"""
+云端腾云引擎
+支持阿里云盘（aligo）的文件及目录结构获取、上传、下载
+"""
+import os
+import logging
+from fr_cli.lang.i18n import T
+from fr_cli.ui.ui import RED, GREEN, RESET
+
+class CloudDisk:
+    def __init__(self, cfg):
+        self.type = cfg.get("type", "")
+        self.client = None
+        self._name = cfg.get("name", "fr-cli")
+        self._cwd = "root"          # 当前云盘目录 ID
+        self._path_map = {}         # 名称 -> {file_id, type, parent_id}
+        self._cwd_stack = [("root", "/")]  # 目录历史栈，支持 cd ..
+
+        if self.type == "aliyundrive":
+            try:
+                from aligo import Aligo
+                # 抑制 aligo 及其子模块的 INFO 日志输出（避免显示 HTTP POST 调用详情）
+                for logger_name in list(logging.root.manager.loggerDict.keys()):
+                    if logger_name.startswith("aligo") or logger_name == "fr-cli":
+                        logging.getLogger(logger_name).setLevel(logging.WARNING)
+                refresh_token = cfg.get("refresh_token")
+                if refresh_token:
+                    self.client = Aligo(name=self._name, refresh_token=refresh_token)
+                else:
+                    self.client = Aligo(name=self._name)
+            except ImportError:
+                self.client = "MISSING:aligo"
+            except Exception as e:
+                self.client = f"ERR:{e}"
+
+    def _check_client(self, lang):
+        """检查客户端状态并返回错误信息"""
+        if not self.client:
+            return None, T("disk_no_cfg", lang)
+        if isinstance(self.client, str):
+            if self.client.startswith("MISSING:"):
+                lib = self.client.split(":")[1]
+                return None, T("disk_miss_dep", lang, lib, lib)
+            if self.client.startswith("ERR:"):
+                return None, f"{T('disk_err', lang)} {self.client[4:]}"
+        return self.client, None
+
+    def ls(self, lang):
+        """列出当前云盘目录的文件和文件夹（带类型标识）"""
+        client, err = self._check_client(lang)
+        if err:
+            return None, err
+        try:
+            files = client.get_file_list(parent_file_id=self._cwd)
+            self._path_map = {}
+            items = []
+            for f in files:
+                is_folder = getattr(f, "type", "") == "folder"
+                self._path_map[f.name] = {
+                    "file_id": f.file_id,
+                    "type": f.type,
+                    "parent_id": self._cwd,
+                }
+                prefix = "📁" if is_folder else "📄"
+                items.append(f"{prefix} {f.name}")
+            return items, None
+        except Exception as e:
+            return None, f"{T('disk_err', lang)} {e}"
+
+    def cd(self, path, lang):
+        """切换云盘目录，支持 .. 返回上级"""
+        client, err = self._check_client(lang)
+        if err:
+            return False, err
+
+        if path == "..":
+            if len(self._cwd_stack) <= 1:
+                return False, f"{RED}已在根目录{RESET}"
+            self._cwd_stack.pop()
+            self._cwd = self._cwd_stack[-1][0]
+            return True, f"{GREEN}✅ 已切换至: {self._cwd_stack[-1][1]}{RESET}"
+
+        # 进入子目录：先刷新当前目录列表
+        self.ls(lang)
+        file_info = self._path_map.get(path)
+        if not file_info:
+            return False, f"{RED}⚠️ 目录不存在: {path}{RESET}"
+        if file_info["type"] != "folder":
+            return False, f"{RED}⚠️ {path} 不是目录{RESET}"
+
+        self._cwd = file_info["file_id"]
+        self._cwd_stack.append((file_info["file_id"], path))
+        return True, f"{GREEN}✅ 已穿梭至: {path}{RESET}"
+
+    def up(self, local_path, cloud_name, lang):
+        """本地文件上传至当前云盘目录"""
+        client, err = self._check_client(lang)
+        if err:
+            return False, err
+        if not os.path.exists(local_path):
+            return False, T("err_no_file", lang)
+        try:
+            result = client.upload_file(
+                file_path=local_path,
+                parent_file_id=self._cwd,
+                name=cloud_name
+            )
+            self._path_map[result.name] = {
+                "file_id": result.file_id,
+                "type": "file",
+                "parent_id": self._cwd,
+            }
+            return True, T("disk_ok_up", lang, result.name)
+        except Exception as e:
+            return False, f"{T('disk_err', lang)} {e}"
+
+    def down(self, cloud_name, local_path, lang):
+        """从当前云盘目录下载文件"""
+        client, err = self._check_client(lang)
+        if err:
+            return False, err
+
+        file_info = self._path_map.get(cloud_name)
+        if not file_info:
+            self.ls(lang)
+            file_info = self._path_map.get(cloud_name)
+
+        if not file_info:
+            return False, T("err_no_file", lang)
+        if file_info["type"] == "folder":
+            return False, f"{RED}⚠️ {cloud_name} 是文件夹，暂不支持单文件下载方式下载文件夹{RED}"
+
+        try:
+            local_folder = os.path.dirname(local_path) or "."
+            client.download_file(
+                file_id=file_info["file_id"],
+                local_folder=local_folder
+            )
+            return True, T("disk_ok_down", lang, local_path)
+        except Exception as e:
+            return False, f"{T('disk_err', lang)} {e}"