jarvis-ai-assistant 0.7.8__py3-none-any.whl → 1.0.2__py3-none-any.whl

jarvis/jarvis_agent/jarvis.py

@@ -1,38 +1,41 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI 助手主入口模块"""
-from typing import Optional, List
+
+import os
 import shutil
+import signal
+import subprocess
+import sys
 from datetime import datetime
+from pathlib import Path
+from typing import Any
+from typing import Dict
+from typing import List
+from typing import Optional
 
 import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
 
+import jarvis.jarvis_utils.utils as jutils
 from jarvis.jarvis_agent.agent_manager import AgentManager
 from jarvis.jarvis_agent.config_editor import ConfigEditor
 from jarvis.jarvis_agent.methodology_share_manager import MethodologyShareManager
 from jarvis.jarvis_agent.tool_share_manager import ToolShareManager
-from jarvis.jarvis_utils.utils import init_env
-from jarvis.jarvis_utils.config import (
-    is_enable_git_repo_jca_switch,
-    is_enable_builtin_config_selector,
-    get_agent_definition_dirs,
-    get_multi_agent_dirs,
-    get_roles_dirs,
-    get_data_dir,
-    set_config,
-    is_non_interactive,
-)
-import jarvis.jarvis_utils.utils as jutils
-from jarvis.jarvis_utils.input import user_confirm, get_single_line_input
+from jarvis.jarvis_utils.config import get_agent_definition_dirs
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_multi_agent_dirs
+from jarvis.jarvis_utils.config import get_roles_dirs
+from jarvis.jarvis_utils.config import is_enable_builtin_config_selector
+from jarvis.jarvis_utils.config import is_enable_git_repo_jca_switch
+from jarvis.jarvis_utils.config import is_non_interactive
+from jarvis.jarvis_utils.config import set_config
 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
-
-import sys
+from jarvis.jarvis_utils.input import get_single_line_input
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.output import PrettyOutput
+from jarvis.jarvis_utils.utils import init_env
 
 
 def _normalize_backup_data_argv(argv: List[str]) -> None:
@@ -47,7 +50,9 @@ def _normalize_backup_data_argv(argv: List[str]) -> None:
             if tok == "--backup-data":
                 # 情况1：位于末尾，无参数
                 # 情况2：后续是下一个选项（以 '-' 开头），表示未提供参数
-                if i == len(argv) - 1 or (i + 1 < len(argv) and argv[i + 1].startswith("-")):
+                if i == len(argv) - 1 or (
+                    i + 1 < len(argv) and argv[i + 1].startswith("-")
+                ):
                     argv.insert(i + 1, "~/jarvis_backups")
                     i += 1  # 跳过我们插入的默认值，避免重复插入
             i += 1
@@ -169,7 +174,7 @@ def handle_interactive_config_option(
             config_data, ask_all=True
         )
         if not changed:
-            print("ℹ️ 没有需要更新的配置项，保持现有配置。")
+            PrettyOutput.auto_print("ℹ️ 没有需要更新的配置项，保持现有配置。")
             return True
 
         # 剔除与 schema 默认值一致的键，保持配置精简
@@ -208,10 +213,10 @@ def handle_interactive_config_option(
                 wf.write(header)
             wf.write(yaml_str)
 
-        print(f"✅ 配置已更新: {config_path}")
+        PrettyOutput.auto_print(f"✅ 配置已更新: {config_path}")
         return True
     except Exception as e:
-        print(f"❌ 交互式配置失败: {e}")
+        PrettyOutput.auto_print(f"❌ 交互式配置失败: {e}")
         return True
 
 
@@ -223,7 +228,7 @@ def handle_backup_option(backup_dir_path: Optional[str]) -> bool:
     init_env("", config_file=None)
     data_dir = Path(get_data_dir())
     if not data_dir.is_dir():
-        print(f"❌ 数据目录不存在: {data_dir}")
+        PrettyOutput.auto_print(f"❌ 数据目录不存在: {data_dir}")
         return True
 
     backup_dir_str = backup_dir_path if backup_dir_path.strip() else "~/jarvis_backups"
@@ -237,14 +242,16 @@ def handle_backup_option(backup_dir_path: Optional[str]) -> bool:
         archive_path = shutil.make_archive(
             str(backup_file_base), "zip", root_dir=str(data_dir)
         )
-        print(f"✅ 数据已成功备份到: {archive_path}")
+        PrettyOutput.auto_print(f"✅ 数据已成功备份到: {archive_path}")
     except Exception as e:
-        print(f"❌ 数据备份失败: {e}")
+        PrettyOutput.auto_print(f"❌ 数据备份失败: {e}")
 
     return True
 
 
-def handle_restore_option(restore_path: Optional[str], config_file: Optional[str]) -> bool:
+def handle_restore_option(
+    restore_path: Optional[str], config_file: Optional[str]
+) -> bool:
     """处理数据恢复选项，返回是否已处理并需提前结束。"""
     if not restore_path:
         return False
@@ -252,11 +259,11 @@ def handle_restore_option(restore_path: Optional[str], config_file: Optional[str
     restore_file = Path(os.path.expanduser(os.path.expandvars(restore_path)))
     # 兼容 ~ 与环境变量，避免用户输入未展开路径导致找不到文件
     if not restore_file.is_file():
-        print(f"❌ 指定的恢复文件不存在: {restore_file}")
+        PrettyOutput.auto_print(f"❌ 指定的恢复文件不存在: {restore_file}")
         return True
 
     # 在恢复数据时不要触发完整环境初始化，避免引导流程或网络请求
-    # 优先从配置文件解析 JARVIS_DATA_PATH，否则回退到默认数据目录
+    # 优先从配置文件解析 data_path，否则回退到默认数据目录
     data_dir_str: Optional[str] = None
     try:
         if config_file:
@@ -265,7 +272,7 @@ def handle_restore_option(restore_path: Optional[str], config_file: Optional[str
                 with open(cfg_path, "r", encoding="utf-8", errors="ignore") as cf:
                     cfg_data = yaml.safe_load(cf) or {}
                 if isinstance(cfg_data, dict):
-                    val = cfg_data.get("JARVIS_DATA_PATH")
+                    val = cfg_data.get("data_path")
                     if isinstance(val, str) and val.strip():
                         data_dir_str = val.strip()
     except Exception:
@@ -280,21 +287,21 @@ def handle_restore_option(restore_path: Optional[str], config_file: Optional[str
         if not user_confirm(
             f"数据目录 '{data_dir}' 已存在，恢复操作将覆盖它。是否继续？", default=False
         ):
-            print("ℹ️ 恢复操作已取消。")
+            PrettyOutput.auto_print("ℹ️ 恢复操作已取消。")
             return True
         try:
             shutil.rmtree(data_dir)
         except Exception as e:
-            print(f"❌ 无法移除现有数据目录: {e}")
+            PrettyOutput.auto_print(f"❌ 无法移除现有数据目录: {e}")
             return True
 
     try:
         data_dir.mkdir(parents=True)
         shutil.unpack_archive(str(restore_file), str(data_dir), "zip")
-        print(f"✅ 数据已从 '{restore_path}' 成功恢复到 '{data_dir}'")
+        PrettyOutput.auto_print(f"✅ 数据已从 '{restore_path}' 成功恢复到 '{data_dir}'")
 
     except Exception as e:
-        print(f"❌ 数据恢复失败: {e}")
+        PrettyOutput.auto_print(f"❌ 数据恢复失败: {e}")
 
     return True
 
@@ -330,7 +337,7 @@ def try_switch_to_jca_if_git_repo(
             if res.returncode == 0:
                 git_root = res.stdout.strip()
                 if git_root and os.path.isdir(git_root):
-                    print(f"ℹ️ 检测到当前位于 Git 仓库: {git_root}")
+                    PrettyOutput.auto_print(f"ℹ️ 检测到当前位于 Git 仓库: {git_root}")
                     if user_confirm(
                         "检测到Git仓库，是否切换到代码开发模式（jca）？", default=False
                     ):
@@ -346,7 +353,9 @@ def try_switch_to_jca_if_git_repo(
                             args += ["--restore-session"]
                         if task:
                             args += ["-r", task]
-                        print("ℹ️ 正在切换到 'jca'（jarvis-code-agent）以进入代码开发模式...")
+                        PrettyOutput.auto_print(
+                            "ℹ️ 正在切换到 'jca'（jarvis-code-agent）以进入代码开发模式..."
+                        )
                         os.execvp(args[0], args)
         except Exception:
             # 静默忽略检测异常，不影响主流程
@@ -385,7 +394,7 @@ def handle_builtin_config_selector(
                     _unique.append(d)
             builtin_dirs = _unique
             # 向后兼容：保留第一个候选作为 builtin_root
-            builtin_root = builtin_dirs[0] if builtin_dirs else None  # type: ignore[assignment]
+            builtin_root = builtin_dirs[0] if builtin_dirs else None
 
             categories = [
                 ("agent", "jarvis-agent", "*.yaml"),
@@ -428,9 +437,13 @@ def handle_builtin_config_selector(
 
                 # 追加内置目录（支持多个候选）
                 try:
-                    candidates = builtin_dirs if isinstance(builtin_dirs, list) and builtin_dirs else ([builtin_root] if builtin_root else [])
+                    candidates = (
+                        builtin_dirs
+                        if isinstance(builtin_dirs, list) and builtin_dirs
+                        else ([builtin_root] if builtin_root else [])
+                    )
                 except Exception:
-                    candidates = ([builtin_root] if builtin_root else [])
+                    candidates = [builtin_root] if builtin_root else []
                 for _bd in candidates:
                     if _bd:
                         search_dirs.append(Path(_bd) / cat)
@@ -449,8 +462,11 @@ def handle_builtin_config_selector(
 
                 # 可选调试输出：查看每类的搜索目录
                 try:
-                    if os.environ.get("JARVIS_DEBUG_BUILTIN_SELECTOR") == "1":
-                        print(f"ℹ️ DEBUG: category={cat} search_dirs=" + ", ".join(str(p) for p in unique_dirs))
+                    if os.environ.get("debug_builtin_selector") == "1":
+                        PrettyOutput.auto_print(
+                            f"ℹ️ DEBUG: category={cat} search_dirs="
+                            + ", ".join(str(p) for p in unique_dirs)
+                        )
                 except Exception:
                     pass
 
@@ -527,7 +543,7 @@ def handle_builtin_config_selector(
                     },
                 )
 
-                print("✅ 可用的内置配置")
+                PrettyOutput.auto_print("✅ 可用的内置配置")
                 # 使用 rich Table 呈现
                 table = Table(show_header=True, header_style="bold magenta")
                 table.add_column("No.", style="cyan", no_wrap=True)
@@ -582,7 +598,8 @@ def handle_builtin_config_selector(
                 else:
                     # Fallback to manual input if fzf is not used or available
                     choice = get_single_line_input(
-                        "选择要启动的配置编号，直接回车使用默认通用代理(jvs): ", default=""
+                        "选择要启动的配置编号，直接回车使用默认通用代理(jvs): ",
+                        default="",
                     )
                     if choice.strip():
                         try:
@@ -632,7 +649,7 @@ def handle_builtin_config_selector(
                                     args += ["-g", str(model_group)]
 
                             if args:
-                                print(f"ℹ️ 正在启动: {' '.join(args)}")
+                                PrettyOutput.auto_print(f"ℹ️ 正在启动: {' '.join(args)}")
                                 os.execvp(args[0], args)
                     except Exception:
                         # 任何异常都不影响默认流程
@@ -695,9 +712,14 @@ def run_cli(
         None, "--restore-data", help="从指定的压缩包恢复 Jarvis 数据"
     ),
     non_interactive: bool = typer.Option(
-        False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
+        False,
+        "-n",
+        "--non-interactive",
+        help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟",
+    ),
+    web: bool = typer.Option(
+        False, "--web", help="以 Web 模式启动，通过浏览器 WebSocket 交互"
     ),
-    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 服务端口"),
     web_launch_cmd: Optional[str] = typer.Option(
@@ -705,7 +727,9 @@ def run_cli(
         "--web-launch-cmd",
         help="交互式终端启动命令（字符串格式，用空格分隔，如: --web-launch-cmd 'jca --task \"xxx\"'）",
     ),
-    stop: bool = typer.Option(False, "--stop", help="停止后台 Web 服务（需与 --web 一起使用）"),
+    stop: bool = typer.Option(
+        False, "--stop", help="停止后台 Web 服务（需与 --web 一起使用）"
+    ),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -714,32 +738,28 @@ def run_cli(
     # 使用 rich 输出命令与快捷方式总览
     print_commands_overview()
 
-    # CLI 标志：非交互模式（不依赖配置文件）
-    if non_interactive:
-        try:
-            os.environ["JARVIS_NON_INTERACTIVE"] = "true"
-        except Exception:
-            pass
-        # 注意：全局配置同步在 init_env 之后执行，避免被覆盖
+    # CLI 标志：非交互模式（不依赖配置文件，仅作为 Agent 实例属性）
 
     # 同步其他 CLI 选项到全局配置，确保后续模块读取一致
     try:
         if model_group:
-            set_config("JARVIS_LLM_GROUP", str(model_group))
+            set_config("llm_group", str(model_group))
         if tool_group:
-            set_config("JARVIS_TOOL_GROUP", str(tool_group))
+            set_config("tool_group", str(tool_group))
         if disable_methodology_analysis:
-            set_config("JARVIS_USE_METHODOLOGY", False)
-            set_config("JARVIS_USE_ANALYSIS", False)
+            set_config("use_methodology", False)
+            set_config("use_analysis", False)
         if restore_session:
-            set_config("JARVIS_RESTORE_SESSION", True)
+            set_config("restore_session", True)
     except Exception:
         # 静默忽略同步异常，不影响主流程
         pass
 
     # 非交互模式要求从命令行传入任务
     if non_interactive and not (task and str(task).strip()):
-        print("❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。")
+        PrettyOutput.auto_print(
+            "❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。"
+        )
         raise typer.Exit(code=2)
 
     # 处理数据备份
@@ -779,10 +799,13 @@ def run_cli(
                 if not pf.exists():
                     # 兼容旧版本：回退检查数据目录中的旧 PID 文件位置
                     try:
-                        pf_alt = Path(os.path.expanduser(os.path.expandvars(get_data_dir()))) / f"jarvis_web_{web_port}.pid"
+                        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_alt = None
+                    if pf_alt and pf_alt.exists():
                         pf = pf_alt
                 if not pf.exists():
                     # 进一步回退：尝试按端口查找并停止（无 PID 文件）
@@ -799,17 +822,23 @@ def run_cli(
                                     candidate_pid = int(ln.strip())
                                     try:
                                         os.kill(candidate_pid, signal.SIGTERM)
-                                        print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
+                                        PrettyOutput.auto_print(
+                                            f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。"
+                                        )
                                         killed_any = True
                                     except Exception as e:
-                                        print(f"⚠️ 按端口停止失败: {e}")
+                                        PrettyOutput.auto_print(
+                                            f"⚠️ 按端口停止失败: {e}"
+                                        )
                                 except Exception:
                                     continue
                     except Exception:
                         pass
                     if not killed_any:
                         try:
-                            res2 = subprocess.run(["ss", "-ltpn"], capture_output=True, text=True)
+                            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:
@@ -817,14 +846,22 @@ def run_cli(
                                             idx = ln.find("pid=")
                                             if idx != -1:
                                                 end = ln.find(",", idx)
-                                                pid_str2 = ln[idx+4:end if end != -1 else None]
+                                                pid_str2 = ln[
+                                                    idx + 4 : end if end != -1 else None
+                                                ]
                                                 candidate_pid = int(pid_str2)
                                                 try:
-                                                    os.kill(candidate_pid, signal.SIGTERM)
-                                                    print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
+                                                    os.kill(
+                                                        candidate_pid, signal.SIGTERM
+                                                    )
+                                                    PrettyOutput.auto_print(
+                                                        f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。"
+                                                    )
                                                     killed_any = True
                                                 except Exception as e:
-                                                    print(f"⚠️ 按端口停止失败: {e}")
+                                                    PrettyOutput.auto_print(
+                                                        f"⚠️ 按端口停止失败: {e}"
+                                                    )
                                                 break
                                         except Exception:
                                             continue
@@ -841,10 +878,14 @@ def run_cli(
                                         p = int(ptxt)
                                         try:
                                             os.kill(p, signal.SIGTERM)
-                                            print(f"✅ 已停止后台 Web 服务 (PID {p})。")
+                                            PrettyOutput.auto_print(
+                                                f"✅ 已停止后台 Web 服务 (PID {p})。"
+                                            )
                                             killed_any = True
                                         except Exception as e:
-                                            print(f"⚠️ 停止 PID {p} 失败: {e}")
+                                            PrettyOutput.auto_print(
+                                                f"⚠️ 停止 PID {p} 失败: {e}"
+                                            )
                                     except Exception:
                                         pass
                                     try:
@@ -854,7 +895,9 @@ def run_cli(
                         except Exception:
                             pass
                     if not killed_any:
-                        print("⚠️ 未找到后台 Web 服务的 PID 文件，可能未启动或已停止。")
+                        PrettyOutput.auto_print(
+                            "⚠️ 未找到后台 Web 服务的 PID 文件，可能未启动或已停止。"
+                        )
                     return
                 # 优先使用 PID 文件中的 PID
                 try:
@@ -866,10 +909,12 @@ def run_cli(
                 if pid > 0:
                     try:
                         os.kill(pid, signal.SIGTERM)
-                        print(f"✅ 已向后台 Web 服务发送停止信号 (PID {pid})。")
+                        PrettyOutput.auto_print(
+                            f"✅ 已向后台 Web 服务发送停止信号 (PID {pid})。"
+                        )
                         killed = True
                     except Exception as e:
-                        print(f"⚠️ 发送停止信号失败或进程不存在: {e}")
+                        PrettyOutput.auto_print(f"⚠️ 发送停止信号失败或进程不存在: {e}")
                 if not killed:
                     # 无 PID 文件或停止失败时，尝试按端口查找进程
                     candidate_pid = 0
@@ -890,7 +935,9 @@ def run_cli(
                         pass
                     if not candidate_pid:
                         try:
-                            res2 = subprocess.run(["ss", "-ltpn"], capture_output=True, text=True)
+                            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:
@@ -899,7 +946,9 @@ def run_cli(
                                             idx = ln.find("pid=")
                                             if idx != -1:
                                                 end = ln.find(",", idx)
-                                                pid_str2 = ln[idx+4:end if end != -1 else None]
+                                                pid_str2 = ln[
+                                                    idx + 4 : end if end != -1 else None
+                                                ]
                                                 candidate_pid = int(pid_str2)
                                                 break
                                         except Exception:
@@ -909,28 +958,33 @@ def run_cli(
                     if candidate_pid:
                         try:
                             os.kill(candidate_pid, signal.SIGTERM)
-                            print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
+                            PrettyOutput.auto_print(
+                                f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。"
+                            )
                             killed = True
                         except Exception as e:
-                            print(f"⚠️ 按端口停止失败: {e}")
+                            PrettyOutput.auto_print(f"⚠️ 按端口停止失败: {e}")
                 # 清理可能存在的 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 = (
+                        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:
-                print(f"❌ 停止后台 Web 服务失败: {e}")
+                PrettyOutput.auto_print(f"❌ 停止后台 Web 服务失败: {e}")
             finally:
                 return
         # 后台启动：父进程拉起子进程并记录 PID
         is_daemon = False
         try:
-            is_daemon = os.environ.get("JARVIS_WEB_DAEMON") == "1"
+            is_daemon = os.environ.get("web_daemon") == "1"
         except Exception:
             is_daemon = False
         if not is_daemon:
@@ -961,7 +1015,7 @@ def run_cli(
                 if web_launch_cmd:
                     args += ["--web-launch-cmd", str(web_launch_cmd)]
                 env = os.environ.copy()
-                env["JARVIS_WEB_DAEMON"] = "1"
+                env["web_daemon"] = "1"
                 # 启动子进程（后台运行）
                 proc = subprocess.Popen(
                     args,
@@ -980,9 +1034,11 @@ def run_cli(
                     pidfile.write_text(str(proc.pid), encoding="utf-8")
                 except Exception:
                     pass
-                print(f"✅ Web 服务已在后台启动 (PID {proc.pid})，地址: http://{web_host}:{web_port}")
+                PrettyOutput.auto_print(
+                    f"✅ Web 服务已在后台启动 (PID {proc.pid})，地址: http://{web_host}:{web_port}"
+                )
             except Exception as e:
-                print(f"❌ 后台启动 Web 服务失败: {e}")
+                PrettyOutput.auto_print(f"❌ 后台启动 Web 服务失败: {e}")
                 raise typer.Exit(code=1)
             return
 
@@ -1007,17 +1063,14 @@ def run_cli(
     # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
     try:
         if model_group:
-            set_config("JARVIS_LLM_GROUP", str(model_group))
+            set_config("llm_group", str(model_group))
         if tool_group:
-            set_config("JARVIS_TOOL_GROUP", str(tool_group))
+            set_config("tool_group", str(tool_group))
         if disable_methodology_analysis:
-            set_config("JARVIS_USE_METHODOLOGY", False)
-            set_config("JARVIS_USE_ANALYSIS", False)
+            set_config("use_methodology", False)
+            set_config("use_analysis", False)
         if restore_session:
-            set_config("JARVIS_RESTORE_SESSION", True)
-        if non_interactive:
-            # 保持运行期非交互标志
-            set_config("JARVIS_NON_INTERACTIVE", True)
+            set_config("restore_session", True)
     except Exception:
         # 静默忽略同步异常，不影响主流程
         pass
@@ -1025,10 +1078,10 @@ def run_cli(
     # 运行主流程
     try:
         # 在 Web 模式下注入基于 WebSocket 的输入/确认回调
-        extra_kwargs = {}
+        extra_kwargs: Dict[str, Any] = {}
         if web:
             # 纯 xterm 交互模式：不注入 WebBridge 的输入/确认回调，避免阻塞等待浏览器响应
-            #（交互由 /terminal PTY 会话中的 jvs 进程处理）
+            # （交互由 /terminal PTY 会话中的 jvs 进程处理）
             pass
 
         agent_manager = AgentManager(
@@ -1044,16 +1097,19 @@ def run_cli(
 
         if web:
             try:
-
+                from jarvis.jarvis_agent.stdio_redirect import enable_web_stdin_redirect
+                from jarvis.jarvis_agent.stdio_redirect import enable_web_stdio_redirect
                 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 的宽度
                     try:
                         from jarvis.jarvis_utils.globals import console as _console
+
                         try:
                             _console._width = 200  # rich Console的固定宽度参数
                         except Exception:
@@ -1077,20 +1133,26 @@ def run_cli(
                     # 解析字符串命令（支持引号）
                     try:
                         import shlex
+
                         launch_cmd = shlex.split(web_launch_cmd.strip())
                         # 调试输出（可选，可以通过环境变量控制）
-                        if os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
-                            print(f"🔍 解析后的启动命令: {launch_cmd}")
+                        if os.environ.get("debug_web_launch_cmd") == "1":
+                            PrettyOutput.auto_print(
+                                f"🔍 解析后的启动命令: {launch_cmd}"
+                            )
                     except Exception:
                         # 如果解析失败，使用简单的空格分割
                         launch_cmd = web_launch_cmd.strip().split()
-                        if os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
-                            print(f"🔍 使用简单分割的启动命令: {launch_cmd}")
+                        if os.environ.get("debug_web_launch_cmd") == "1":
+                            PrettyOutput.auto_print(
+                                f"🔍 使用简单分割的启动命令: {launch_cmd}"
+                            )
                 else:
                     # 如果没有指定，则自动构建（移除 web 相关参数）
                     try:
-                        import sys as _sys
                         import os as _os
+                        import sys as _sys
+
                         _argv = list(_sys.argv)
                         # 去掉程序名（argv[0]），并过滤 --web 相关参数
                         filtered = []
@@ -1125,22 +1187,32 @@ def run_cli(
                         launch_cmd = ["jvs"] + filtered
                     except Exception:
                         pass
-                
+
                 # 同时写入环境变量作为备选（向后兼容）
                 if launch_cmd:
                     try:
-                        import os as _os
                         import json as _json
-                        _os.environ["JARVIS_WEB_LAUNCH_JSON"] = _json.dumps(launch_cmd, ensure_ascii=False)
+                        import os as _os
+
+                        _os.environ["web_launch_json"] = _json.dumps(
+                            launch_cmd, ensure_ascii=False
+                        )
                     except Exception:
                         pass
-                
-                print("ℹ️ 以 Web 模式启动，请在浏览器中打开提供的地址进行交互。")
+
+                PrettyOutput.auto_print(
+                    "ℹ️ 以 Web 模式启动，请在浏览器中打开提供的地址进行交互。"
+                )
                 # 启动 Web 服务（阻塞调用），传入启动命令
-                start_web_server(agent_manager, host=web_host, port=web_port, launch_command=launch_cmd)
+                start_web_server(
+                    agent_manager,
+                    host=web_host,
+                    port=web_port,
+                    launch_command=launch_cmd,
+                )
                 return
             except Exception as e:
-                print(f"❌ Web 模式启动失败: {e}")
+                PrettyOutput.auto_print(f"❌ Web 模式启动失败: {e}")
                 raise typer.Exit(code=1)
 
         # 默认 CLI 模式：运行任务（可能来自 --task 或交互输入）
@@ -1148,7 +1220,7 @@ def run_cli(
     except typer.Exit:
         raise
     except Exception as err:  # pylint: disable=broad-except
-        print(f"❌ 初始化错误: {str(err)}")
+        PrettyOutput.auto_print(f"❌ 初始化错误: {str(err)}")
         raise typer.Exit(code=1)