jarvis-ai-assistant 0.3.34__py3-none-any.whl → 0.4.1__py3-none-any.whl

jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.3.34"
+__version__ = "0.4.1"

jarvis/jarvis_agent/__init__.py

@@ -31,6 +31,8 @@ from jarvis.jarvis_agent.prompts import (
     TASK_ANALYSIS_PROMPT,
 )
 from jarvis.jarvis_tools.registry import ToolRegistry
+from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
+from jarvis.jarvis_agent.rewrite_file_handler import RewriteFileHandler
 from jarvis.jarvis_agent.prompt_manager import PromptManager
 from jarvis.jarvis_agent.event_bus import EventBus
 from jarvis.jarvis_agent.config import AgentConfig
@@ -54,6 +56,9 @@ from jarvis.jarvis_agent.events import (
 from jarvis.jarvis_agent.user_interaction import UserInteractionHandler
 from jarvis.jarvis_agent.utils import join_prompts
 from jarvis.jarvis_utils.methodology import _load_all_methodologies
+from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
+from jarvis.jarvis_agent.file_context_handler import file_context_handler
+from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
 
 # jarvis_platform 相关
 from jarvis.jarvis_platform.base import BasePlatform
@@ -71,6 +76,7 @@ from jarvis.jarvis_utils.config import (
     is_use_methodology,
     get_tool_filter_threshold,
     get_after_tool_call_cb_dirs,
+    set_config,
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import (
@@ -274,7 +280,6 @@ class Agent:
         auto_complete: bool = False,
         output_handler: Optional[List[OutputHandlerProtocol]] = None,
         use_tools: Optional[List[str]] = None,
-        input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]] = None,
         execute_tool_confirm: Optional[bool] = None,
         need_summary: bool = True,
         multiline_inputer: Optional[Callable[[str], str]] = None,
@@ -283,6 +288,8 @@ class Agent:
         force_save_memory: Optional[bool] = None,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
+        **kwargs,
     ):
         """初始化Jarvis Agent实例
 
@@ -293,8 +300,6 @@ class Agent:
 
             summary_prompt: 任务总结提示模板
             auto_complete: 是否自动完成任务
-            output_handler: 输出处理器列表
-            input_handler: 输入处理器列表
             execute_tool_confirm: 执行工具前是否需要确认
             need_summary: 是否需要生成总结
             multiline_inputer: 多行输入处理器
@@ -302,6 +307,7 @@ class Agent:
             use_analysis: 是否使用任务分析
             force_save_memory: 是否强制保存记忆
             confirm_callback: 用户确认回调函数，签名为 (tip: str, default: bool) -> bool；默认使用CLI的user_confirm
+            non_interactive: 是否以非交互模式运行（优先级最高，覆盖环境变量与配置）
         """
         # 基础属性初始化
         self.files = files or []
@@ -326,15 +332,33 @@ class Agent:
 
         # 初始化处理器
         self._init_handlers(
-            output_handler or [],
-            input_handler,
             multiline_inputer,
+            output_handler,
             use_tools or [],
         )
         # 初始化用户交互封装，保持向后兼容
         self.user_interaction = UserInteractionHandler(self.multiline_inputer, self.user_confirm)
         # 将确认函数指向封装后的 confirm，保持既有调用不变
         self.user_confirm = self.user_interaction.confirm  # type: ignore[assignment]
+        # 非交互模式参数支持：允许通过构造参数显式控制，便于其他Agent调用时设置
+        try:
+            # 优先使用构造参数，其次回退到环境变量
+            self.non_interactive = (
+                bool(non_interactive)
+                if non_interactive is not None
+                else str(os.environ.get("JARVIS_NON_INTERACTIVE", "")).lower() in ("1", "true", "yes")
+            )
+            # 如果构造参数显式提供，则同步到环境变量与全局配置，供下游组件读取
+            if non_interactive is not None:
+                os.environ["JARVIS_NON_INTERACTIVE"] = "true" if self.non_interactive else "false"
+                try:
+                    set_config("JARVIS_NON_INTERACTIVE", self.non_interactive)
+                except Exception:
+                    # 配置同步失败不影响主流程
+                    pass
+        except Exception:
+            # 防御式回退
+            self.non_interactive = False
 
         # 初始化配置
         self._init_config(
@@ -394,15 +418,18 @@ class Agent:
 
     def _init_handlers(
         self,
-        output_handler: List[OutputHandlerProtocol],
-        input_handler: Optional[List[Callable[[str, Any], Tuple[str, bool]]]],
         multiline_inputer: Optional[Callable[[str], str]],
+        output_handler: Optional[List[OutputHandlerProtocol]],
         use_tools: List[str],
     ):
         """初始化各种处理器"""
-        self.output_handler = output_handler or [ToolRegistry()]
+        self.output_handler = output_handler or [ToolRegistry(),  EditFileHandler(), RewriteFileHandler()]
         self.set_use_tools(use_tools)
-        self.input_handler = input_handler or []
+        self.input_handler = [
+            builtin_input_handler,
+            shell_input_handler,
+            file_context_handler,
+        ]
         self.multiline_inputer = multiline_inputer or get_multiline_input
 
     def _init_config(
@@ -897,13 +924,17 @@ class Agent:
 
         if self.need_summary:
 
-            self.session.prompt = self.summary_prompt
+            # 确保总结提示词非空：若为None或仅空白，则回退到默认提示词
+            safe_summary_prompt = self.summary_prompt or ""
+            if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() == "":
+                safe_summary_prompt = DEFAULT_SUMMARY_PROMPT
+            # 注意：不要写回 session.prompt，避免 BEFORE_SUMMARY 事件回调修改/清空后导致使用空prompt
             # 广播将要生成总结事件
             try:
                 self.event_bus.emit(
                     BEFORE_SUMMARY,
                     agent=self,
-                    prompt=self.session.prompt,
+                    prompt=safe_summary_prompt,
                     auto_completed=auto_completed,
                     need_summary=self.need_summary,
                 )
@@ -912,7 +943,8 @@ class Agent:
 
             if not self.model:
                 raise RuntimeError("Model not initialized")
-            ret = self.model.chat_until_success(self.session.prompt)  # type: ignore
+            # 直接使用本地变量，避免受事件回调影响
+            ret = self.model.chat_until_success(safe_summary_prompt)  # type: ignore
             # 防御: 总结阶段模型可能返回空响应(None或空字符串)，统一为空字符串并告警
             if not ret:
                 try:

jarvis/jarvis_agent/agent_manager.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """Agent管理器模块，负责Agent的初始化和任务执行"""
-from typing import Optional
+from typing import Optional, Callable
 
 import typer
 
@@ -16,7 +16,7 @@ from jarvis.jarvis_agent.file_context_handler import file_context_handler
 from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
 from jarvis.jarvis_agent.task_manager import TaskManager
 from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_utils.config import is_non_interactive
+from jarvis.jarvis_utils.config import is_non_interactive, is_skip_predefined_tasks
 
 
 class AgentManager:
@@ -29,6 +29,9 @@ class AgentManager:
         restore_session: bool = False,
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
+        multiline_inputer: Optional[Callable[[str], str]] = None,
+        confirm_callback: Optional[Callable[[str, bool], bool]] = None,
+        non_interactive: Optional[bool] = None,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
@@ -36,6 +39,10 @@ class AgentManager:
         self.use_methodology = use_methodology
         self.use_analysis = use_analysis
         self.agent: Optional[Agent] = None
+        # 可选：注入输入与确认回调，用于Web模式等前端替代交互
+        self.multiline_inputer = multiline_inputer
+        self.confirm_callback = confirm_callback
+        self.non_interactive = non_interactive
 
     def initialize(self) -> Agent:
         """初始化Agent"""
@@ -48,15 +55,12 @@ class AgentManager:
         self.agent = Agent(
             system_prompt=origin_agent_system_prompt,
             model_group=self.model_group,
-            input_handler=[
-                shell_input_handler,
-                file_context_handler,
-                builtin_input_handler,
-            ],
-            output_handler=[ToolRegistry()],  # type: ignore
             need_summary=False,
             use_methodology=self.use_methodology,
             use_analysis=self.use_analysis,
+            multiline_inputer=self.multiline_inputer,
+            confirm_callback=self.confirm_callback,
+            non_interactive=self.non_interactive,
         )
 
         # 尝试恢复会话
@@ -78,8 +82,8 @@ class AgentManager:
             self.agent.run(task_content)
             raise typer.Exit(code=0)
 
-        # 处理预定义任务（非交互模式下跳过）
-        if not is_non_interactive() and self.agent.first:
+        # 处理预定义任务（非交互模式下跳过；支持配置跳过加载）
+        if not is_non_interactive() and not is_skip_predefined_tasks() and self.agent.first:
             task_manager = TaskManager()
             tasks = task_manager.load_tasks()
             if tasks and (selected_task := task_manager.select_task(tasks)):

jarvis/jarvis_agent/config.py

@@ -81,7 +81,8 @@ class AgentConfig:
             cfg.execute_tool_confirm = is_execute_tool_confirm()
 
         # summary_prompt
-        if cfg.summary_prompt is None:
+        # Treat None or whitespace-only string as unset, fallback to default
+        if cfg.summary_prompt is None or (isinstance(cfg.summary_prompt, str) and cfg.summary_prompt.strip() == ""):
             cfg.summary_prompt = DEFAULT_SUMMARY_PROMPT
 
         # max_token_count

jarvis/jarvis_agent/edit_file_handler.py

@@ -92,10 +92,10 @@ class EditFileHandler(OutputHandler):
         if not patches:
             return False, "未找到有效的文件编辑指令"
 
-        # 记录 edit_file 工具调用统计
+        # 记录 PATCH 操作调用统计
         from jarvis.jarvis_stats.stats import StatsManager
 
-        StatsManager.increment("edit_file", group="tool")
+        StatsManager.increment("patch", group="tool")
 
         results = []
 

jarvis/jarvis_agent/jarvis.py

@@ -28,6 +28,7 @@ from jarvis.jarvis_utils.fzf import fzf_select
 import os
 import subprocess
 from pathlib import Path
+import signal
 import yaml  # type: ignore
 from rich.table import Table
 from rich.console import Console
@@ -594,7 +595,10 @@ def handle_builtin_config_selector(
 
                             elif sel["category"] == "multi_agent":
                                 # jarvis-multi-agent 需要 -c/--config，用户输入通过 -i/--input 传递
+                                # 同时传递 -g/--llm-group 以继承 jvs 的模型组选择
                                 args = [str(sel["cmd"]), "-c", str(sel["file"])]
+                                if model_group:
+                                    args += ["-g", str(model_group)]
                                 if task:
                                     args += ["-i", str(task)]
 
@@ -677,6 +681,10 @@ def run_cli(
     non_interactive: bool = typer.Option(
         False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
     ),
+    web: bool = typer.Option(False, "--web", help="以 Web 模式启动，通过浏览器 WebSocket 交互"),
+    web_host: str = typer.Option("127.0.0.1", "--web-host", help="Web 服务主机"),
+    web_port: int = typer.Option(8765, "--web-port", help="Web 服务端口"),
+    stop: bool = typer.Option(False, "--stop", help="停止后台 Web 服务（需与 --web 一起使用）"),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -742,6 +750,224 @@ def run_cli(
 
     # 预加载配置（仅用于读取功能开关），不会显示欢迎信息或影响后续 init_env
     preload_config_for_flags(config_file)
+    # Web 模式后台管理：支持 --web 后台启动与 --web --stop 停止
+    if web:
+        # PID 文件路径（按端口区分，便于多实例）
+        pidfile = Path(os.path.expanduser("~/.jarvis")) / f"jarvis_web_{web_port}.pid"
+        # 停止后台服务
+        if stop:
+            try:
+                pf = pidfile
+                if not pf.exists():
+                    # 兼容旧版本：回退检查数据目录中的旧 PID 文件位置
+                    try:
+                        pf_alt = Path(os.path.expanduser(os.path.expandvars(get_data_dir()))) / f"jarvis_web_{web_port}.pid"
+                    except Exception:
+                        pf_alt = None  # type: ignore[assignment]
+                    if pf_alt and pf_alt.exists():  # type: ignore[truthy-bool]
+                        pf = pf_alt
+                if not pf.exists():
+                    # 进一步回退：尝试按端口查找并停止（无 PID 文件）
+                    killed_any = False
+                    try:
+                        res = subprocess.run(
+                            ["lsof", "-iTCP:%d" % web_port, "-sTCP:LISTEN", "-t"],
+                            capture_output=True,
+                            text=True,
+                        )
+                        if res.returncode == 0 and res.stdout.strip():
+                            for ln in res.stdout.strip().splitlines():
+                                try:
+                                    candidate_pid = int(ln.strip())
+                                    try:
+                                        os.kill(candidate_pid, signal.SIGTERM)
+                                        PrettyOutput.print(f"已按端口停止后台 Web 服务 (PID {candidate_pid})。", OutputType.SUCCESS)
+                                        killed_any = True
+                                    except Exception as e:
+                                        PrettyOutput.print(f"按端口停止失败: {e}", OutputType.WARNING)
+                                except Exception:
+                                    continue
+                    except Exception:
+                        pass
+                    if not killed_any:
+                        try:
+                            res2 = subprocess.run(["ss", "-ltpn"], capture_output=True, text=True)
+                            if res2.returncode == 0 and res2.stdout:
+                                for ln in res2.stdout.splitlines():
+                                    if f":{web_port} " in ln or f":{web_port}\n" in ln:
+                                        try:
+                                            idx = ln.find("pid=")
+                                            if idx != -1:
+                                                end = ln.find(",", idx)
+                                                pid_str2 = ln[idx+4:end if end != -1 else None]
+                                                candidate_pid = int(pid_str2)
+                                                try:
+                                                    os.kill(candidate_pid, signal.SIGTERM)
+                                                    PrettyOutput.print(f"已按端口停止后台 Web 服务 (PID {candidate_pid})。", OutputType.SUCCESS)
+                                                    killed_any = True
+                                                except Exception as e:
+                                                    PrettyOutput.print(f"按端口停止失败: {e}", OutputType.WARNING)
+                                                break
+                                        except Exception:
+                                            continue
+                        except Exception:
+                            pass
+                    # 若仍未找到，扫描家目录下所有 Web PID 文件，尽力停止所有实例
+                    if not killed_any:
+                        try:
+                            pid_dir = Path(os.path.expanduser("~/.jarvis"))
+                            if pid_dir.is_dir():
+                                for f in pid_dir.glob("jarvis_web_*.pid"):
+                                    try:
+                                        ptxt = f.read_text(encoding="utf-8").strip()
+                                        p = int(ptxt)
+                                        try:
+                                            os.kill(p, signal.SIGTERM)
+                                            PrettyOutput.print(f"已停止后台 Web 服务 (PID {p})。", OutputType.SUCCESS)
+                                            killed_any = True
+                                        except Exception as e:
+                                            PrettyOutput.print(f"停止 PID {p} 失败: {e}", OutputType.WARNING)
+                                    except Exception:
+                                        pass
+                                    try:
+                                        f.unlink(missing_ok=True)
+                                    except Exception:
+                                        pass
+                        except Exception:
+                            pass
+                    if not killed_any:
+                        PrettyOutput.print("未找到后台 Web 服务的 PID 文件，可能未启动或已停止。", OutputType.WARNING)
+                    return
+                # 优先使用 PID 文件中的 PID
+                try:
+                    pid_str = pf.read_text(encoding="utf-8").strip()
+                    pid = int(pid_str)
+                except Exception:
+                    pid = 0
+                killed = False
+                if pid > 0:
+                    try:
+                        os.kill(pid, signal.SIGTERM)
+                        PrettyOutput.print(f"已向后台 Web 服务发送停止信号 (PID {pid})。", OutputType.SUCCESS)
+                        killed = True
+                    except Exception as e:
+                        PrettyOutput.print(f"发送停止信号失败或进程不存在: {e}", OutputType.WARNING)
+                if not killed:
+                    # 无 PID 文件或停止失败时，尝试按端口查找进程
+                    candidate_pid = 0
+                    try:
+                        res = subprocess.run(
+                            ["lsof", "-iTCP:%d" % web_port, "-sTCP:LISTEN", "-t"],
+                            capture_output=True,
+                            text=True,
+                        )
+                        if res.returncode == 0 and res.stdout.strip():
+                            for ln in res.stdout.strip().splitlines():
+                                try:
+                                    candidate_pid = int(ln.strip())
+                                    break
+                                except Exception:
+                                    continue
+                    except Exception:
+                        pass
+                    if not candidate_pid:
+                        try:
+                            res2 = subprocess.run(["ss", "-ltpn"], capture_output=True, text=True)
+                            if res2.returncode == 0 and res2.stdout:
+                                for ln in res2.stdout.splitlines():
+                                    if f":{web_port} " in ln or f":{web_port}\n" in ln:
+                                        # 格式示例: LISTEN ... users:(("uvicorn",pid=12345,fd=7))
+                                        try:
+                                            idx = ln.find("pid=")
+                                            if idx != -1:
+                                                end = ln.find(",", idx)
+                                                pid_str2 = ln[idx+4:end if end != -1 else None]
+                                                candidate_pid = int(pid_str2)
+                                                break
+                                        except Exception:
+                                            continue
+                        except Exception:
+                            pass
+                    if candidate_pid:
+                        try:
+                            os.kill(candidate_pid, signal.SIGTERM)
+                            PrettyOutput.print(f"已按端口停止后台 Web 服务 (PID {candidate_pid})。", OutputType.SUCCESS)
+                            killed = True
+                        except Exception as e:
+                            PrettyOutput.print(f"按端口停止失败: {e}", OutputType.WARNING)
+                # 清理可能存在的 PID 文件（两个位置）
+                try:
+                    pidfile.unlink(missing_ok=True)  # 家目录位置
+                except Exception:
+                    pass
+                try:
+                    alt_pf = Path(os.path.expanduser(os.path.expandvars(get_data_dir()))) / f"jarvis_web_{web_port}.pid"
+                    alt_pf.unlink(missing_ok=True)
+                except Exception:
+                    pass
+            except Exception as e:
+                PrettyOutput.print(f"停止后台 Web 服务失败: {e}", OutputType.ERROR)
+            finally:
+                return
+        # 后台启动：父进程拉起子进程并记录 PID
+        is_daemon = False
+        try:
+            is_daemon = os.environ.get("JARVIS_WEB_DAEMON") == "1"
+        except Exception:
+            is_daemon = False
+        if not is_daemon:
+            try:
+                # 构建子进程参数，传递关键配置
+                args = [
+                    sys.executable,
+                    "-m",
+                    "jarvis.jarvis_agent.jarvis",
+                    "--web",
+                    "--web-host",
+                    str(web_host),
+                    "--web-port",
+                    str(web_port),
+                ]
+                if model_group:
+                    args += ["-g", str(model_group)]
+                if tool_group:
+                    args += ["-G", str(tool_group)]
+                if config_file:
+                    args += ["-f", str(config_file)]
+                if restore_session:
+                    args += ["--restore-session"]
+                if disable_methodology_analysis:
+                    args += ["-D"]
+                if non_interactive:
+                    args += ["-n"]
+                env = os.environ.copy()
+                env["JARVIS_WEB_DAEMON"] = "1"
+                # 启动子进程（后台运行）
+                proc = subprocess.Popen(
+                    args,
+                    env=env,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    stdin=subprocess.DEVNULL,
+                    close_fds=True,
+                )
+                # 记录 PID 到文件
+                try:
+                    pidfile.parent.mkdir(parents=True, exist_ok=True)
+                except Exception:
+                    pass
+                try:
+                    pidfile.write_text(str(proc.pid), encoding="utf-8")
+                except Exception:
+                    pass
+                PrettyOutput.print(
+                    f"Web 服务已在后台启动 (PID {proc.pid})，地址: http://{web_host}:{web_port}",
+                    OutputType.SUCCESS,
+                )
+            except Exception as e:
+                PrettyOutput.print(f"后台启动 Web 服务失败: {e}", OutputType.ERROR)
+                raise typer.Exit(code=1)
+            return
 
     # 在初始化环境前检测Git仓库，并可选择自动切换到代码开发模式（jca）
     if not non_interactive:
@@ -779,14 +1005,92 @@ def run_cli(
 
     # 运行主流程
     try:
+        # 在 Web 模式下注入基于 WebSocket 的输入/确认回调
+        extra_kwargs = {}
+        if web:
+            # 纯 xterm 交互模式：不注入 WebBridge 的输入/确认回调，避免阻塞等待浏览器响应
+            #（交互由 /terminal PTY 会话中的 jvs 进程处理）
+            pass
+
         agent_manager = AgentManager(
             model_group=model_group,
             tool_group=tool_group,
             restore_session=restore_session,
             use_methodology=False if disable_methodology_analysis else None,
             use_analysis=False if disable_methodology_analysis else None,
+            non_interactive=non_interactive,
+            **extra_kwargs,
         )
-        agent_manager.initialize()
+        agent = agent_manager.initialize()
+
+        if web:
+            try:
+
+                from jarvis.jarvis_agent.web_server import start_web_server
+                from jarvis.jarvis_agent.stdio_redirect import enable_web_stdio_redirect, enable_web_stdin_redirect
+                # 在 Web 模式下固定TTY宽度为200，改善前端显示效果
+                try:
+                    import os as _os
+                    _os.environ["COLUMNS"] = "200"
+                    # 尝试固定全局 Console 的宽度（PrettyOutput 使用该 Console 实例）
+                    try:
+                        from jarvis.jarvis_utils.globals import console as _console
+                        try:
+                            _console._width = 200  # rich Console的固定宽度参数
+                        except Exception:
+                            pass
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
+                # 使用 STDIO 重定向，取消 Sink 广播以避免重复输出
+                # 启用标准输出/错误的WebSocket重定向（捕获工具直接打印的输出）
+                enable_web_stdio_redirect()
+                # 启用来自前端 xterm 的 STDIN 重定向，使交互式命令可从浏览器获取输入
+                try:
+                    enable_web_stdin_redirect()
+                except Exception:
+                    pass
+                # 记录用于交互式终端（PTY）重启的 jvs 启动命令（移除 web 相关参数）
+                try:
+                    import sys as _sys, os as _os, json as _json
+                    _argv = list(_sys.argv)
+                    # 去掉程序名（argv[0]），并过滤 --web 相关参数
+                    filtered = []
+                    i = 1
+                    while i < len(_argv):
+                        a = _argv[i]
+                        if a == "--web" or a.startswith("--web="):
+                            i += 1
+                            continue
+                        if a == "--web-host":
+                            i += 2
+                            continue
+                        if a.startswith("--web-host="):
+                            i += 1
+                            continue
+                        if a == "--web-port":
+                            i += 2
+                            continue
+                        if a.startswith("--web-port="):
+                            i += 1
+                            continue
+                        filtered.append(a)
+                        i += 1
+                    # 使用 jvs 命令作为可执行文件，保留其余业务参数
+                    cmd = ["jvs"] + filtered
+                    _os.environ["JARVIS_WEB_LAUNCH_JSON"] = _json.dumps(cmd, ensure_ascii=False)
+                except Exception:
+                    pass
+                PrettyOutput.print("以 Web 模式启动，请在浏览器中打开提供的地址进行交互。", OutputType.INFO)
+                # 启动 Web 服务（阻塞调用）
+                start_web_server(agent_manager, host=web_host, port=web_port)
+                return
+            except Exception as e:
+                PrettyOutput.print(f"Web 模式启动失败: {e}", OutputType.ERROR)
+                raise typer.Exit(code=1)
+
+        # 默认 CLI 模式：运行任务（可能来自 --task 或交互输入）
         agent_manager.run_task(task)
     except typer.Exit:
         raise