myagent-ai 1.0.0 → 1.2.0

package/README.md

@@ -105,26 +105,45 @@ myagent/
 
 ---
 
-## 🚀 快速开始
+## 🚀 一键安装
 
-### 1. 安装依赖
+> 💡 **无需手动安装 Python、Node.js 等依赖**，脚本会自动检测并安装所有前置条件。仅复制一行命令即可完成安装。
+
+### Windows（PowerShell）
+
+```powershell
+powershell -c "irm https://raw.githubusercontent.com/ctz168/myagent/main/install/install.ps1 | iex"
+```
+
+> 首次运行时如果 PowerShell 提示执行策略限制，先执行：`Set-ExecutionPolicy RemoteSigned -Scope CurrentUser`
+
+### macOS / Linux
 
 ```bash
-# 克隆项目
-git clone https://github.com/ctz168/myagent.git
-cd myagent
-
-# 安装核心依赖
-pip install -r requirements.txt
-
-# 按需安装聊天平台
-pip install python-telegram-bot   # Telegram
-pip install discord.py            # Discord
-pip install playwright && playwright install chromium  # 浏览器
-pip install anthropic            # Claude
+curl -fsSL https://raw.githubusercontent.com/ctz168/myagent/main/install/install.sh | bash
 ```
 
-### 2. 配置 LLM
+---
+
+## 📋 系统要求
+
+| 项目 | 最低要求 | 推荐配置 |
+|------|----------|----------|
+| **操作系统** | Windows 10 / macOS 12 / Ubuntu 20.04 | Windows 11 / macOS 14 / Ubuntu 24.04 |
+| **Python** | 3.10+ | 3.12+ |
+| **Node.js** | 18+ (LTS) | 20+ (LTS) |
+| **内存** | 512 MB | 2 GB+ |
+| **磁盘空间** | 200 MB | 500 MB+ |
+
+> 安装脚本会自动检测并安装 Python 3.12 和 Node.js 20 LTS，你不需要提前准备任何环境。
+
+---
+
+## ⚙️ 安装后配置
+
+安装完成后，运行 `myagent-ai` 即可启动。首次运行会自动创建配置文件 `~/.myagent/config.json`。
+
+### 1. 配置 LLM
 
 **方式一: 环境变量 (推荐)**
 ```bash
@@ -135,7 +154,7 @@ export MYAGENT_LLM_MODEL="gpt-4"
 **方式二: 配置文件**
 ```bash
 # 首次运行会自动创建 ~/.myagent/config.json
-python main.py
+myagent-ai
 ```
 
 **方式三: 使用 Ollama 本地模型 (免费)**
@@ -155,23 +174,23 @@ export MYAGENT_LLM_PROVIDER="anthropic"
 export MYAGENT_ANTHROPIC_API_KEY="sk-ant-..."
 ```
 
-### 3. 运行
+### 2. 运行
 
 ```bash
 # 交互式命令行
-python main.py
+myagent-ai
 
 # 系统托盘后台运行
-python main.py --tray
+myagent-ai --tray
 
 # 调试模式
-python main.py --debug
+myagent-ai --debug
 
 # 设置开机自启
-python main.py --autostart
+myagent-ai --autostart
 ```
 
-### 4. 配置聊天平台 (可选)
+### 3. 配置聊天平台 (可选)
 
 编辑 `~/.myagent/config.json`:
 

package/agents/base.py

@@ -18,6 +18,21 @@ from core.utils import generate_id, timestamp
 logger = get_logger("myagent.agent")
 
 
+# 全局权限管理器实例（由 main.py 初始化）
+_global_permission_manager = None
+
+
+def set_permission_manager(pm):
+    """设置全局权限管理器（应用启动时调用一次）"""
+    global _global_permission_manager
+    _global_permission_manager = pm
+
+
+def get_permission_manager():
+    """获取全局权限管理器"""
+    return _global_permission_manager
+
+
 @dataclass
 class AgentContext:
     """Agent 上下文，在 Agent 之间传递"""
@@ -59,6 +74,7 @@ class BaseAgent(ABC):
         self.task_queue = task_queue
         self.config = config or {}
         self.config_broadcaster = config_broadcaster
+        self._permission_manager = None  # 延迟绑定，在 process 时获取
         self._stats = {"total_tasks": 0, "success": 0, "failed": 0}
 
     @abstractmethod
@@ -113,3 +129,44 @@ class BaseAgent(ABC):
 
     def get_stats(self) -> Dict:
         return dict(self._stats)
+
+    # ── 权限检查 ────────────────────────────────────────────
+
+    @property
+    def permission_manager(self):
+        """获取权限管理器（延迟绑定）"""
+        if self._permission_manager is None:
+            from agents.base import get_permission_manager
+            self._permission_manager = get_permission_manager()
+        return self._permission_manager
+
+    def check_permission(self, permission: str) -> bool:
+        """
+        检查当前 agent 是否拥有某项权限。
+
+        Args:
+            permission: 权限项名称 (execution/file_read/file_write/network/local_comm/remote_comm)
+
+        Returns:
+            True 如果权限开启，或权限管理器未初始化（向后兼容）
+        """
+        pm = self.permission_manager
+        if pm is None:
+            # 权限管理器未初始化，允许所有操作（向后兼容）
+            return True
+        return pm.check_permission(self.name, permission)
+
+    def require_permission(self, permission: str) -> bool:
+        """
+        要求指定权限，权限不足时记录警告并返回 False。
+
+        Args:
+            permission: 权限项名称
+
+        Returns:
+            True 如果权限通过
+        """
+        pm = self.permission_manager
+        if pm is None:
+            return True
+        return pm.require_permission(self.name, permission)

package/agents/main_agent.py

@@ -13,6 +13,7 @@ from core.logger import get_logger
 from core.llm import LLMClient, LLMResponse, Message
 from agents.base import BaseAgent, AgentContext
 from core.utils import generate_id, timestamp, safe_json_parse, truncate_str
+from core.context_manager import ContextManager, ContextConfig, estimate_tokens
 
 logger = get_logger("myagent.agent.main")
 
@@ -111,7 +112,9 @@ class MainAgent(BaseAgent):
         self._registered_task: bool = False
         # 组织上下文缓存（避免重复加载）
         self._org_context_cache: str = ""
-        self._org_context_loaded: bool = False
+        self._org_context_mtime: float = 0  # 文件修改时间，用于检测变更
+        # Token 上下文管理器 (滚动摘要 + 预算控制)
+        self.context_manager = ContextManager(ContextConfig())
 
     async def process(self, context: AgentContext) -> AgentContext:
         """
@@ -180,12 +183,15 @@ class MainAgent(BaseAgent):
 
             # 检查配置热加载广播（每次迭代前检查）
             if self.config_broadcaster:
-                reloaded = await self.config_broadcaster.check_and_wait(task_id)
+                reloaded, reload_type = await self.config_broadcaster.check_and_wait(task_id)
                 if reloaded:
-                    logger.info(f"[{task_id}] 🔄 配置已热更新，继续执行 (iteration={self._iteration_count})")
+                    logger.info(f"[{task_id}] 🔄 {reload_type}已热更新，继续执行 (iteration={self._iteration_count})")
                     # 更新迭代检查点
                     if self.config_broadcaster._active_tasks.get(task_id):
                         self.config_broadcaster._active_tasks[task_id].iteration = self._iteration_count
+                    # 代码热更新后，LLM 客户端可能已被刷新，下次调用会自动重建
+                    if reload_type == "code":
+                        logger.info(f"[{task_id}] 代码模块已热更新，LLM 客户端将在下次调用时自动重建")
 
             # 构建消息列表
             messages = self._build_messages(context)
@@ -205,21 +211,22 @@ class MainAgent(BaseAgent):
 
             # 检查是否有工具调用 (OpenAI function calling)
             if response.tool_calls:
+                # 先将 assistant 的 tool_calls 消息加入历史（OpenAI 格式要求）
+                context.conversation_history.append(
+                    Message(role="assistant",
+                           content=response.content or "",
+                           tool_calls=response.tool_calls)
+                )
+                # 执行工具调用
                 tool_results = await self._handle_tool_calls(
                     response.tool_calls, context, task_id
                 )
-                # 将工具结果加入消息历史
+                # 再将工具结果加入消息历史
                 for tc, result in tool_results:
                     context.conversation_history.append(
                         Message(role="tool", content=json.dumps(result, ensure_ascii=False),
                                tool_call_id=tc["id"], name=tc["name"])
                     )
-                    context.conversation_history.append(
-                        Message(role="assistant",
-                               content=f"[已调用工具 {tc['name']}，结果: "
-                                       f"{'成功' if result.get('success') else '失败'}]",
-                               tool_calls=[tc])
-                    )
                 # 继续循环，让 LLM 处理工具结果
                 continue
 
@@ -275,6 +282,39 @@ class MainAgent(BaseAgent):
                             final_response += "\n\n已完成: " + " → ".join(action_data["plan"])
                         break
 
+                    # 如果有超时且诊断建议不重试，强制中断循环避免无效重试
+                    if has_timeout:
+                        should_abort = False
+                        abort_reasons = []
+                        for i, r in enumerate(results, 1):
+                            if r.get("timed_out"):
+                                diag = r.get("timeout_diagnosis", {})
+                                if diag.get("should_retry") is False:
+                                    should_abort = True
+                                    abort_reasons.append(
+                                        f"命令{i}: {diag.get('diagnosis', '不可恢复的超时')}"
+                                    )
+                        if should_abort:
+                            logger.warning(
+                                f"[{task_id}] ⛔ 超时诊断建议不重试，终止当前执行循环 "
+                                f"(iteration={self._iteration_count})"
+                            )
+                            # 构建诊断反馈，强制LLM输出final_answer
+                            abort_msg = (
+                                "[系统通知] 以下命令因超时被终止，且超时诊断结果表明不应重试:\n"
+                            )
+                            for reason in abort_reasons:
+                                abort_msg += f"- {reason}\n"
+                            abort_msg += (
+                                "\n请直接以纯文本或 {\"type\": \"final_answer\", \"content\": \"...\"} "
+                                "格式回复，告知用户任务无法完成的原因和建议的替代方案。"
+                                "不要再尝试执行相同的命令。"
+                            )
+                            context.conversation_history.append(
+                                Message(role="user", content=abort_msg)
+                            )
+                            continue  # 让LLM生成final_answer，而不是重试命令
+
                     continue
 
                 # 单个 action
@@ -300,44 +340,59 @@ class MainAgent(BaseAgent):
 
         logger.info(f"[{task_id}] 处理完成 (迭代 {self._iteration_count} 次)")
 
-        # 检查是否需要总结对话
+        # 检查是否需要增量总结对话 (使用滚动摘要，不再清空短期记忆)
         if self.memory_agent and self._iteration_count > 5:
             try:
-                await self.memory_agent.process(AgentContext(
+                summary_context = AgentContext(
                     session_id=context.session_id,
                     metadata={"memory_action": "summarize"},
-                ))
+                )
+                await self.memory_agent.process(summary_context)
+                # 将生成的摘要更新到 ContextManager 的滚动摘要缓冲
+                summary_result = summary_context.working_memory.get("summary_result", "")
+                if summary_result:
+                    self.context_manager.summary_buffer.update_summary(
+                        session_id=context.session_id,
+                        new_summary=summary_result,
+                        summarized_count=summary_context.working_memory.get("summarized_count", 0),
+                    )
+                    logger.info(
+                        f"[{task_id}] 滚动摘要已更新 (session={context.session_id})"
+                    )
             except Exception as e:
                 logger.warning(f"对话总结失败: {e}")
 
         return context
 
     def _build_messages(self, context: AgentContext) -> List[Message]:
-        """构建完整的消息列表"""
-        messages = [Message(role="system", content=self.SYSTEM_PROMPT)]
-
-        # 添加组织上下文（如果已启用）
+        """构建完整的消息列表 (使用 ContextManager 进行 Token 预算优化)"""
+        # 合并系统提示 + 组织上下文
+        system_prompt = self.SYSTEM_PROMPT
         org_context = self._build_org_context(context)
         if org_context:
-            messages.append(Message(
-                role="system",
-                content=org_context,
-            ))
+            system_prompt += "\n\n" + org_context
 
-        # 添加记忆上下文
+        # 记忆上下文
         memory_ctx = context.working_memory.get("memory_context_prompt", "")
-        if memory_ctx:
-            messages.append(Message(
-                role="system",
-                content=f"[记忆上下文]\n{memory_ctx}",
-            ))
-
-        # 添加对话历史
-        for msg in context.conversation_history[-20:]:
-            messages.append(msg)
 
-        # 添加当前用户消息
-        messages.append(Message(role="user", content=context.user_message))
+        # 使用 ContextManager 构建优化后的消息列表
+        raw_messages = self.context_manager.build_context(
+            system_prompt=system_prompt,
+            memory_context=memory_ctx,
+            conversation_history=context.conversation_history,
+            user_message=context.user_message,
+            session_id=context.session_id,
+        )
+
+        # 转换回 Message 对象 (ContextManager 返回 dict)
+        messages = []
+        for m in raw_messages:
+            if isinstance(m, dict):
+                messages.append(Message(**m))
+            elif isinstance(m, Message):
+                messages.append(m)
+            else:
+                messages.append(m)
 
         return messages
 
@@ -351,6 +406,31 @@ class MainAgent(BaseAgent):
             logger.warning(f"获取工具列表失败: {e}")
             return None
 
+    @staticmethod
+    def _get_skill_permission(skill_name: str) -> Optional[str]:
+        """
+        根据技能名称映射到对应的权限项。
+
+        Returns:
+            权限项名称，或 None（不需要特殊权限的技能）
+        """
+        # 文件技能
+        if skill_name in ("file_write", "file_delete", "file_move"):
+            return "file_write"
+        if skill_name in ("file_read", "file_list", "file_search"):
+            return "file_read"
+        # 网络/搜索技能
+        if skill_name in ("web_search", "web_read", "url_read"):
+            return "network"
+        # 系统技能涉及执行
+        if skill_name in ("command_run",):
+            return "execution"
+        # 浏览器技能需要网络
+        if skill_name in ("browser_open", "browser_click", "browser_fill"):
+            return "network"
+        # 其他技能不需要特殊权限检查
+        return None
+
     async def _handle_tool_calls(
         self,
         tool_calls: List[Dict],
@@ -397,6 +477,19 @@ class MainAgent(BaseAgent):
             action_type = action.get("type", "")
 
             if action_type == "skill" and self.skills:
+                # 权限检查: 根据技能类别检查权限
+                skill_name = action.get("name", "")
+                skill_perm = self._get_skill_permission(skill_name)
+                if skill_perm and not self.check_permission(skill_perm):
+                    from core.permissions import PermissionManager
+                    label = PermissionManager.PERMISSION_LABELS.get(skill_perm, skill_perm)
+                    results.append({
+                        "success": False,
+                        "error": f"[权限] 当前 Agent 没有'{label}'权限，操作被拒绝",
+                        "metadata": {"permission_denied": skill_perm},
+                    })
+                    continue
+
                 result = await self.skills.execute(
                     action.get("name", ""),
                     **action.get("params", {}),
@@ -404,6 +497,19 @@ class MainAgent(BaseAgent):
                 results.append(result.to_dict())
 
             elif action_type == "code" and self.executor:
+                # 权限检查: execution
+                if not self.check_permission("execution"):
+                    results.append({
+                        "success": False,
+                        "error": "[权限] 当前 Agent 没有代码执行权限，操作被拒绝",
+                        "metadata": {"permission_denied": "execution"},
+                    })
+                    continue
+
+                # 注入权限检查器到 executor（用于更细粒度的检查）
+                self.executor.set_permission_checker(
+                    self.check_permission, self.name
+                )
                 # 提取 LLM 预估的超时时间
                 timeout_seconds = action.get("timeout_seconds")
                 if timeout_seconds is None:
@@ -636,22 +742,25 @@ class MainAgent(BaseAgent):
 
             parts = []
 
-            # 1. 读取 organization.md（使用缓存避免重复读取）
-            if not self._org_context_loaded:
-                try:
-                    from config import get_config
-                    config_mgr = get_config()
-                    org_dir = config_mgr.data_dir / "organization"
-                    org_info_path = org_dir / "organization.md"
-                    if org_info_path.exists():
+            # 1. 读取 organization.md（使用 mtime 缓存检测变更）
+            try:
+                from config import get_config
+                config_mgr = get_config()
+                org_dir = config_mgr.data_dir / "organization"
+                org_info_path = org_dir / "organization.md"
+                if org_info_path.exists():
+                    current_mtime = org_info_path.stat().st_mtime
+                    if current_mtime != self._org_context_mtime:
                         content = org_info_path.read_text(encoding="utf-8")
                         # 检查是否仍是模板（包含占位注释）
                         is_template = "<!-- 在此填写" in content
                         if not is_template:
                             self._org_context_cache = content
-                except Exception as e:
-                    logger.debug(f"读取组织信息失败: {e}")
-                self._org_context_loaded = True
+                        else:
+                            self._org_context_cache = ""
+                        self._org_context_mtime = current_mtime
+            except Exception as e:
+                logger.debug(f"读取组织信息失败: {e}")
 
             if self._org_context_cache:
                 parts.append("## 组织信息\n")

package/agents/memory_agent.py

@@ -192,7 +192,13 @@ class MemoryAgent(BaseAgent):
         ]
 
     async def _summarize(self, context: AgentContext, session_id: str):
-        """总结当前对话"""
+        """
+        增量总结当前对话 (滚动摘要模式)。
+
+        变更: 不再清空短期记忆，而是生成摘要并返回给 MainAgent，
+        由 ContextManager 的 RollingSummaryBuffer 管理滚动摘要。
+        同时仍将偏好和错误经验提取到长期记忆。
+        """
         if not self.memory or not self.llm:
             return
 
@@ -213,9 +219,12 @@ class MemoryAgent(BaseAgent):
 
         result = await self._call_llm_json(messages)
         if "error" not in result:
+            summary_text = result.get("summary", "")
+
+            # 保存摘要到长期记忆 (保留原有功能)
             self.memory.save_summary(
                 session_id=session_id,
-                summary=result.get("summary", ""),
+                summary=summary_text,
             )
 
             # 保存偏好
@@ -235,9 +244,20 @@ class MemoryAgent(BaseAgent):
                     fix=err_item.get("fix", ""),
                 )
 
-            logger.info(f"对话已总结并保存到长期记忆 (session={session_id})")
-            # 清理已总结的旧对话
-            self.memory.clear_conversation(session_id)
+            # 返回摘要结果供 ContextManager 的滚动摘要缓冲使用
+            # (不再清空短期记忆，保持对话连续性)
+            key_points = result.get("key_points", [])
+            full_summary = summary_text
+            if key_points:
+                full_summary += "\n要点: " + "; ".join(key_points)
+
+            context.working_memory["summary_result"] = full_summary
+            context.working_memory["summarized_count"] = len(entries)
+
+            logger.info(
+                f"对话增量总结完成 (session={session_id}, "
+                f"entries={len(entries)}, 不再清空短期记忆)"
+            )
 
     async def _record_error(self, context: AgentContext, session_id: str):
         """记录错误模式"""

package/communication/manager.py

@@ -61,6 +61,7 @@ class CommunicationManager:
         """
         self.config = config
         self._data_dir = Path(data_dir) if data_dir else Path.home() / ".myagent" / "data"
+        self._permission_checker = None  # callable(perm_name) -> bool, set by app
 
         # Identity keys (Ed25519)
         self._ed_priv: bytes = b""
@@ -255,6 +256,9 @@ class CommunicationManager:
         msg = None
         # Check if the peer is on this machine (has a local queue)
         if to_agent in LocalChannel._queues:
+            # 本机通信权限检查
+            if not self._check_permission("local_comm"):
+                raise RuntimeError("[权限] 当前 Agent 没有本机通信权限")
             msg = await self._local_channel.send(
                 to_agent=to_agent,
                 content=content,
@@ -262,6 +266,9 @@ class CommunicationManager:
                 their_public_key=their_pub,
             )
         elif self._remote_channel:
+            # 跨电脑通信权限检查
+            if not self._check_permission("remote_comm"):
+                raise RuntimeError("[权限] 当前 Agent 没有跨电脑通信权限，请先在权限管理中开启")
             their_x_pub_hex = peer.permissions.get("x25519_public_key", "")
             msg = await self._remote_channel.send(
                 to_agent=to_agent,
@@ -371,6 +378,19 @@ class CommunicationManager:
         """Register a callback for incoming messages."""
         self._message_callbacks.append(callback)
 
+    def set_permission_checker(self, checker):
+        """设置权限检查回调（由应用启动时注入）"""
+        self._permission_checker = checker
+
+    def _check_permission(self, permission: str) -> bool:
+        """检查权限，无权限检查器时默认通过"""
+        if self._permission_checker is None:
+            return True
+        try:
+            return bool(self._permission_checker(permission))
+        except Exception:
+            return True
+
     # ==================================================================
     # Status
     # ==================================================================

package/core/__init__.py

@@ -1,10 +1,4 @@
 """
-core/__init__.py - 核心模块初始化
+core/__init__.py - 核心模块
 """
-from core.logger import setup_logger, get_logger
-from core.utils import (
-    timestamp, generate_id, truncate_str,
-    safe_json_parse, validate_json_schema
-)
-from core.llm import LLMClient, get_llm_client
-from core.task_queue import TaskQueue, TaskItem, TaskStatus
+from core.version import __version__