jarvis-ai-assistant 0.3.30__py3-none-any.whl → 0.7.6__py3-none-any.whl

jarvis/jarvis_agent/jarvis.py

@@ -1,10 +1,11 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI 助手主入口模块"""
 from typing import Optional, List
+import shutil
+from datetime import datetime
 
 import typer
 
-from jarvis.jarvis_agent import OutputType, PrettyOutput
 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
@@ -16,6 +17,9 @@ from jarvis.jarvis_utils.config import (
     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
@@ -23,10 +27,37 @@ 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
+
+
+def _normalize_backup_data_argv(argv: List[str]) -> None:
+    """
+    兼容旧版 Click/Typer 对可选参数的解析差异：
+    若用户仅提供 --backup-data 而不跟参数，则在解析前注入默认目录。
+    """
+    try:
+        i = 0
+        while i < len(argv):
+            tok = argv[i]
+            if tok == "--backup-data":
+                # 情况1：位于末尾，无参数
+                # 情况2：后续是下一个选项（以 '-' 开头），表示未提供参数
+                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
+    except Exception:
+        # 静默忽略任何异常，避免影响主流程
+        pass
+
+
+_normalize_backup_data_argv(sys.argv)
+
 app = typer.Typer(help="Jarvis AI 助手")
 
 
@@ -138,7 +169,7 @@ def handle_interactive_config_option(
             config_data, ask_all=True
         )
         if not changed:
-            PrettyOutput.print("没有需要更新的配置项，保持现有配置。", OutputType.INFO)
+            print("ℹ️ 没有需要更新的配置项，保持现有配置。")
             return True
 
         # 剔除与 schema 默认值一致的键，保持配置精简
@@ -177,13 +208,97 @@ def handle_interactive_config_option(
                 wf.write(header)
             wf.write(yaml_str)
 
-        PrettyOutput.print(f"配置已更新: {config_path}", OutputType.SUCCESS)
+        print(f"✅ 配置已更新: {config_path}")
         return True
     except Exception as e:
-        PrettyOutput.print(f"交互式配置失败: {e}", OutputType.ERROR)
+        print(f"❌ 交互式配置失败: {e}")
         return True
 
 
+def handle_backup_option(backup_dir_path: Optional[str]) -> bool:
+    """处理数据备份选项，返回是否已处理并需提前结束。"""
+    if backup_dir_path is None:
+        return False
+
+    init_env("", config_file=None)
+    data_dir = Path(get_data_dir())
+    if not data_dir.is_dir():
+        print(f"❌ 数据目录不存在: {data_dir}")
+        return True
+
+    backup_dir_str = backup_dir_path if backup_dir_path.strip() else "~/jarvis_backups"
+    backup_dir = Path(os.path.expanduser(backup_dir_str))
+    backup_dir.mkdir(exist_ok=True)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_file_base = backup_dir / f"jarvis_data_{timestamp}"
+
+    try:
+        archive_path = shutil.make_archive(
+            str(backup_file_base), "zip", root_dir=str(data_dir)
+        )
+        print(f"✅ 数据已成功备份到: {archive_path}")
+    except Exception as e:
+        print(f"❌ 数据备份失败: {e}")
+
+    return True
+
+
+def handle_restore_option(restore_path: Optional[str], config_file: Optional[str]) -> bool:
+    """处理数据恢复选项，返回是否已处理并需提前结束。"""
+    if not restore_path:
+        return False
+
+    restore_file = Path(os.path.expanduser(os.path.expandvars(restore_path)))
+    # 兼容 ~ 与环境变量，避免用户输入未展开路径导致找不到文件
+    if not restore_file.is_file():
+        print(f"❌ 指定的恢复文件不存在: {restore_file}")
+        return True
+
+    # 在恢复数据时不要触发完整环境初始化，避免引导流程或网络请求
+    # 优先从配置文件解析 JARVIS_DATA_PATH，否则回退到默认数据目录
+    data_dir_str: Optional[str] = None
+    try:
+        if config_file:
+            cfg_path = Path(os.path.expanduser(os.path.expandvars(config_file)))
+            if cfg_path.is_file():
+                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")
+                    if isinstance(val, str) and val.strip():
+                        data_dir_str = val.strip()
+    except Exception:
+        data_dir_str = None
+
+    if not data_dir_str:
+        data_dir_str = get_data_dir()
+
+    data_dir = Path(os.path.expanduser(os.path.expandvars(str(data_dir_str))))
+
+    if data_dir.exists():
+        if not user_confirm(
+            f"数据目录 '{data_dir}' 已存在，恢复操作将覆盖它。是否继续？", default=False
+        ):
+            print("ℹ️ 恢复操作已取消。")
+            return True
+        try:
+            shutil.rmtree(data_dir)
+        except Exception as e:
+            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}'")
+
+    except Exception as e:
+        print(f"❌ 数据恢复失败: {e}")
+
+    return True
+
+
 def preload_config_for_flags(config_file: Optional[str]) -> None:
     """预加载配置（仅用于读取功能开关），不会显示欢迎信息或影响后续 init_env。"""
     try:
@@ -202,6 +317,9 @@ def try_switch_to_jca_if_git_repo(
     task: Optional[str],
 ) -> None:
     """在初始化环境前检测Git仓库，并可选择自动切换到代码开发模式（jca）。"""
+    # 非交互模式下跳过代码模式切换提示与相关输出
+    if is_non_interactive():
+        return
     if is_enable_git_repo_jca_switch():
         try:
             res = subprocess.run(
@@ -212,9 +330,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):
-                    PrettyOutput.print(
-                        f"检测到当前位于 Git 仓库: {git_root}", OutputType.INFO
-                    )
+                    print(f"ℹ️ 检测到当前位于 Git 仓库: {git_root}")
                     if user_confirm(
                         "检测到Git仓库，是否切换到代码开发模式（jca）？", default=False
                     ):
@@ -230,10 +346,7 @@ def try_switch_to_jca_if_git_repo(
                             args += ["--restore-session"]
                         if task:
                             args += ["-r", task]
-                        PrettyOutput.print(
-                            "正在切换到 'jca'（jarvis-code-agent）以进入代码开发模式...",
-                            OutputType.INFO,
-                        )
+                        print("ℹ️ 正在切换到 'jca'（jarvis-code-agent）以进入代码开发模式...")
                         os.execvp(args[0], args)
         except Exception:
             # 静默忽略检测异常，不影响主流程
@@ -249,10 +362,30 @@ def handle_builtin_config_selector(
     """在进入默认通用代理前，列出内置配置供选择（agent/multi_agent/roles）。"""
     if is_enable_builtin_config_selector():
         try:
-            # 优先使用项目内置目录，若不存在则回退到指定的绝对路径
-            builtin_root = Path(__file__).resolve().parents[3] / "builtin"
-            if not builtin_root.exists():
-                builtin_root = Path("/home/skyfire/code/Jarvis/builtin")
+            # 查找可用的 builtin 目录（支持多候选）
+            builtin_dirs: List[Path] = []
+            try:
+                ancestors = list(Path(__file__).resolve().parents)
+                for anc in ancestors[:8]:
+                    p = anc / "builtin"
+                    if p.exists():
+                        builtin_dirs.append(p)
+            except Exception:
+                pass
+            # 去重，保留顺序
+            _seen = set()
+            _unique: List[Path] = []
+            for d in builtin_dirs:
+                try:
+                    key = str(d.resolve())
+                except Exception:
+                    key = str(d)
+                if key not in _seen:
+                    _seen.add(key)
+                    _unique.append(d)
+            builtin_dirs = _unique
+            # 向后兼容：保留第一个候选作为 builtin_root
+            builtin_root = builtin_dirs[0] if builtin_dirs else None  # type: ignore[assignment]
 
             categories = [
                 ("agent", "jarvis-agent", "*.yaml"),
@@ -293,8 +426,14 @@ def handle_builtin_config_selector(
                     # 忽略配置读取异常
                     pass
 
-                # 追加内置目录
-                search_dirs.append(builtin_root / cat)
+                # 追加内置目录（支持多个候选）
+                try:
+                    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 [])
+                for _bd in candidates:
+                    if _bd:
+                        search_dirs.append(Path(_bd) / cat)
 
                 # 去重并保留顺序
                 unique_dirs = []
@@ -308,11 +447,11 @@ def handle_builtin_config_selector(
                         seen.add(key)
                         unique_dirs.append(Path(d))
 
-                # 每日自动更新配置目录（如目录为Git仓库则执行git pull，每日仅一次）
+                # 可选调试输出：查看每类的搜索目录
                 try:
-                    jutils.daily_check_git_updates([str(p) for p in unique_dirs], cat)
+                    if os.environ.get("JARVIS_DEBUG_BUILTIN_SELECTOR") == "1":
+                        print(f"ℹ️ DEBUG: category={cat} search_dirs=" + ", ".join(str(p) for p in unique_dirs))
                 except Exception:
-                    # 忽略更新过程中的所有异常，避免影响主流程
                     pass
 
                 for dir_path in unique_dirs:
@@ -374,7 +513,21 @@ def handle_builtin_config_selector(
                         )
 
             if options:
-                PrettyOutput.section("可用的内置配置", OutputType.SUCCESS)
+                # Add a default option to skip selection
+                options.insert(
+                    0,
+                    {
+                        "category": "skip",
+                        "cmd": "",
+                        "file": "",
+                        "name": "跳过选择 (使用默认通用代理)",
+                        "desc": "直接按回车或ESC也可跳过",
+                        "details": "",
+                        "roles_count": 0,
+                    },
+                )
+
+                print("✅ 可用的内置配置")
                 # 使用 rich Table 呈现
                 table = Table(show_header=True, header_style="bold magenta")
                 table.add_column("No.", style="cyan", no_wrap=True)
@@ -442,35 +595,45 @@ def handle_builtin_config_selector(
                 if choice_index != -1:
                     try:
                         sel = options[choice_index]
-                        args: List[str] = []
-
-                        if sel["category"] == "agent":
-                            # jarvis-agent 支持 -f/--config（全局配置）与 -c/--agent-definition
-                            args = [str(sel["cmd"]), "-c", str(sel["file"])]
-                            if model_group:
-                                args += ["-g", str(model_group)]
-                            if config_file:
-                                args += ["-f", str(config_file)]
-                            if task:
-                                args += ["--task", str(task)]
-
-                        elif sel["category"] == "multi_agent":
-                            # jarvis-multi-agent 需要 -c/--config，用户输入通过 -i/--input 传递
-                            args = [str(sel["cmd"]), "-c", str(sel["file"])]
-                            if task:
-                                args += ["-i", str(task)]
-
-                        elif sel["category"] == "roles":
-                            # jarvis-platform-manager role 子命令，支持 -c/-t/-g
-                            args = [str(sel["cmd"]), "role", "-c", str(sel["file"])]
-                            if model_group:
-                                args += ["-g", str(model_group)]
-
-                        if args:
-                            PrettyOutput.print(
-                                f"正在启动: {' '.join(args)}", OutputType.INFO
-                            )
-                            os.execvp(args[0], args)
+                        # If the "skip" option is chosen, do nothing and proceed to default agent
+                        if sel["category"] == "skip":
+                            pass
+                        else:
+                            args: List[str] = []
+
+                            if sel["category"] == "agent":
+                                # jarvis-agent 支持 -f/--config（全局配置）与 -c/--agent-definition
+                                args = [str(sel["cmd"]), "-c", str(sel["file"])]
+                                if model_group:
+                                    args += ["-g", str(model_group)]
+                                if config_file:
+                                    args += ["-f", str(config_file)]
+                                if task:
+                                    args += ["--task", str(task)]
+
+                            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)]
+
+                            elif sel["category"] == "roles":
+                                # jarvis-platform-manager role 子命令，支持 -c/-t/-g
+                                args = [
+                                    str(sel["cmd"]),
+                                    "role",
+                                    "-c",
+                                    str(sel["file"]),
+                                ]
+                                if model_group:
+                                    args += ["-g", str(model_group)]
+
+                            if args:
+                                print(f"ℹ️ 正在启动: {' '.join(args)}")
+                                os.execvp(args[0], args)
                     except Exception:
                         # 任何异常都不影响默认流程
                         pass
@@ -521,6 +684,28 @@ def run_cli(
         "--disable-methodology-analysis",
         help="禁用方法论和任务分析（覆盖配置文件设置）",
     ),
+    backup_data: Optional[str] = typer.Option(
+        None,
+        "--backup-data",
+        help="备份 Jarvis 数据目录. 可选地传入备份目录. 默认为 '~/jarvis_backups'",
+        show_default=False,
+        flag_value="~/jarvis_backups",
+    ),
+    restore_data: Optional[str] = typer.Option(
+        None, "--restore-data", help="从指定的压缩包恢复 Jarvis 数据"
+    ),
+    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 服务端口"),
+    web_launch_cmd: Optional[str] = typer.Option(
+        None,
+        "--web-launch-cmd",
+        help="交互式终端启动命令（字符串格式，用空格分隔，如: --web-launch-cmd 'jca --task \"xxx\"'）",
+    ),
+    stop: bool = typer.Option(False, "--stop", help="停止后台 Web 服务（需与 --web 一起使用）"),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -529,6 +714,42 @@ def run_cli(
     # 使用 rich 输出命令与快捷方式总览
     print_commands_overview()
 
+    # CLI 标志：非交互模式（不依赖配置文件）
+    if non_interactive:
+        try:
+            os.environ["JARVIS_NON_INTERACTIVE"] = "true"
+        except Exception:
+            pass
+        # 注意：全局配置同步在 init_env 之后执行，避免被覆盖
+
+    # 同步其他 CLI 选项到全局配置，确保后续模块读取一致
+    try:
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
+        if tool_group:
+            set_config("JARVIS_TOOL_GROUP", str(tool_group))
+        if disable_methodology_analysis:
+            set_config("JARVIS_USE_METHODOLOGY", False)
+            set_config("JARVIS_USE_ANALYSIS", False)
+        if restore_session:
+            set_config("JARVIS_RESTORE_SESSION", True)
+    except Exception:
+        # 静默忽略同步异常，不影响主流程
+        pass
+
+    # 非交互模式要求从命令行传入任务
+    if non_interactive and not (task and str(task).strip()):
+        print("❌ 非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。")
+        raise typer.Exit(code=2)
+
+    # 处理数据备份
+    if handle_backup_option(backup_data):
+        return
+
+    # 处理数据恢复
+    if handle_restore_option(restore_data, config_file):
+        return
+
     # 处理配置文件编辑
     if handle_edit_option(edit, config_file):
         return
@@ -547,35 +768,387 @@ 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)
+                                        print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
+                                        killed_any = True
+                                    except Exception as e:
+                                        print(f"⚠️ 按端口停止失败: {e}")
+                                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)
+                                                    print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
+                                                    killed_any = True
+                                                except Exception as e:
+                                                    print(f"⚠️ 按端口停止失败: {e}")
+                                                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)
+                                            print(f"✅ 已停止后台 Web 服务 (PID {p})。")
+                                            killed_any = True
+                                        except Exception as e:
+                                            print(f"⚠️ 停止 PID {p} 失败: {e}")
+                                    except Exception:
+                                        pass
+                                    try:
+                                        f.unlink(missing_ok=True)
+                                    except Exception:
+                                        pass
+                        except Exception:
+                            pass
+                    if not killed_any:
+                        print("⚠️ 未找到后台 Web 服务的 PID 文件，可能未启动或已停止。")
+                    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)
+                        print(f"✅ 已向后台 Web 服务发送停止信号 (PID {pid})。")
+                        killed = True
+                    except Exception as e:
+                        print(f"⚠️ 发送停止信号失败或进程不存在: {e}")
+                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)
+                            print(f"✅ 已按端口停止后台 Web 服务 (PID {candidate_pid})。")
+                            killed = True
+                        except Exception as e:
+                            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.unlink(missing_ok=True)
+                except Exception:
+                    pass
+            except Exception as e:
+                print(f"❌ 停止后台 Web 服务失败: {e}")
+            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"]
+                if web_launch_cmd:
+                    args += ["--web-launch-cmd", str(web_launch_cmd)]
+                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
+                print(f"✅ Web 服务已在后台启动 (PID {proc.pid})，地址: http://{web_host}:{web_port}")
+            except Exception as e:
+                print(f"❌ 后台启动 Web 服务失败: {e}")
+                raise typer.Exit(code=1)
+            return
 
     # 在初始化环境前检测Git仓库，并可选择自动切换到代码开发模式（jca）
-    try_switch_to_jca_if_git_repo(
-        model_group, tool_group, config_file, restore_session, task
-    )
+    # 如果指定了 -T/--task 参数，跳过切换提示
+    if not non_interactive and not task:
+        try_switch_to_jca_if_git_repo(
+            model_group, tool_group, config_file, restore_session, task
+        )
 
     # 在进入默认通用代理前，列出内置配置供选择（agent/multi_agent/roles）
-    handle_builtin_config_selector(model_group, tool_group, config_file, task)
+    # 非交互模式下跳过内置角色/配置选择
+    # 如果指定了 -T/--task 参数，跳过配置选择
+    if not non_interactive and not task:
+        handle_builtin_config_selector(model_group, tool_group, config_file, task)
 
     # 初始化环境
     init_env(
         "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file
     )
 
+    # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
+    try:
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
+        if tool_group:
+            set_config("JARVIS_TOOL_GROUP", str(tool_group))
+        if disable_methodology_analysis:
+            set_config("JARVIS_USE_METHODOLOGY", False)
+            set_config("JARVIS_USE_ANALYSIS", False)
+        if restore_session:
+            set_config("JARVIS_RESTORE_SESSION", True)
+        if non_interactive:
+            # 保持运行期非交互标志
+            set_config("JARVIS_NON_INTERACTIVE", True)
+    except Exception:
+        # 静默忽略同步异常，不影响主流程
+        pass
+
     # 运行主流程
     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()
+
+        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 的宽度
+                    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）重启的启动命令
+                launch_cmd = None
+                # 优先使用命令行参数指定的启动命令
+                if web_launch_cmd and web_launch_cmd.strip():
+                    # 解析字符串命令（支持引号）
+                    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}")
+                    except Exception:
+                        # 如果解析失败，使用简单的空格分割
+                        launch_cmd = web_launch_cmd.strip().split()
+                        if os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
+                            print(f"🔍 使用简单分割的启动命令: {launch_cmd}")
+                else:
+                    # 如果没有指定，则自动构建（移除 web 相关参数）
+                    try:
+                        import sys as _sys
+                        import os as _os
+                        _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
+                            if a == "--web-launch-cmd":
+                                # 跳过 --web-launch-cmd 及其值
+                                i += 2
+                                continue
+                            if a.startswith("--web-launch-cmd="):
+                                i += 1
+                                continue
+                            filtered.append(a)
+                            i += 1
+                        # 使用 jvs 命令作为可执行文件，保留其余业务参数
+                        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)
+                    except Exception:
+                        pass
+                
+                print("ℹ️ 以 Web 模式启动，请在浏览器中打开提供的地址进行交互。")
+                # 启动 Web 服务（阻塞调用），传入启动命令
+                start_web_server(agent_manager, host=web_host, port=web_port, launch_command=launch_cmd)
+                return
+            except Exception as e:
+                print(f"❌ Web 模式启动失败: {e}")
+                raise typer.Exit(code=1)
+
+        # 默认 CLI 模式：运行任务（可能来自 --task 或交互输入）
         agent_manager.run_task(task)
     except typer.Exit:
         raise
     except Exception as err:  # pylint: disable=broad-except
-        PrettyOutput.print(f"初始化错误: {str(err)}", OutputType.ERROR)
+        print(f"❌ 初始化错误: {str(err)}")
         raise typer.Exit(code=1)