jarvis-ai-assistant 0.3.33__py3-none-any.whl → 0.4.0__py3-none-any.whl

jarvis/__init__.py

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

jarvis/jarvis_agent/__init__.py

@@ -54,6 +54,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
@@ -274,7 +277,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,
@@ -294,7 +296,6 @@ class Agent:
             summary_prompt: 任务总结提示模板
             auto_complete: 是否自动完成任务
             output_handler: 输出处理器列表
-            input_handler: 输入处理器列表
             execute_tool_confirm: 执行工具前是否需要确认
             need_summary: 是否需要生成总结
             multiline_inputer: 多行输入处理器
@@ -327,7 +328,6 @@ class Agent:
         # 初始化处理器
         self._init_handlers(
             output_handler or [],
-            input_handler,
             multiline_inputer,
             use_tools or [],
         )
@@ -395,14 +395,17 @@ 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]],
         use_tools: List[str],
     ):
         """初始化各种处理器"""
         self.output_handler = output_handler or [ToolRegistry()]
         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(
@@ -439,6 +442,8 @@ class Agent:
         self.summary_prompt = cfg.summary_prompt or DEFAULT_SUMMARY_PROMPT
         self.max_token_count = int(cfg.max_token_count or get_max_token_count(model_group))
         self.force_save_memory = bool(cfg.force_save_memory)
+        # 非交互模式下自动完成标志需要同步到 Agent 实例，避免循环
+        self.auto_complete = bool(cfg.auto_complete)
 
         # 聚合配置到 AgentConfig，作为后续单一事实来源（保持兼容，不改变既有属性使用）
         self.config = cfg

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,6 +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
 
 
 class AgentManager:
@@ -28,6 +29,8 @@ 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,
     ):
         self.model_group = model_group
         self.tool_group = tool_group
@@ -35,6 +38,9 @@ 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
 
     def initialize(self) -> Agent:
         """初始化Agent"""
@@ -47,15 +53,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,
         )
 
         # 尝试恢复会话
@@ -77,8 +80,8 @@ class AgentManager:
             self.agent.run(task_content)
             raise typer.Exit(code=0)
 
-        # 处理预定义任务
-        if self.agent.first:
+        # 处理预定义任务（非交互模式下跳过）
+        if not is_non_interactive() 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

@@ -17,6 +17,7 @@ from jarvis.jarvis_utils.config import (
     is_force_save_memory,
     is_use_analysis,
     is_use_methodology,
+    is_non_interactive,
 )
 
 
@@ -30,6 +31,7 @@ class AgentConfig:
 
     # 运行行为
     auto_complete: bool = False
+    non_interactive: bool = False
     need_summary: bool = True
 
     # 可选配置（None 表示使用默认策略解析）
@@ -53,6 +55,7 @@ class AgentConfig:
             description=self.description,
             model_group=self.model_group,
             auto_complete=self.auto_complete,
+            non_interactive=self.non_interactive,
             need_summary=self.need_summary,
             summary_prompt=self.summary_prompt,
             execute_tool_confirm=self.execute_tool_confirm,
@@ -89,4 +92,8 @@ class AgentConfig:
         if cfg.force_save_memory is None:
             cfg.force_save_memory = is_force_save_memory()
 
+        # 非交互模式下默认开启自动完成
+        if is_non_interactive():
+            cfg.auto_complete = True
+
         return cfg

jarvis/jarvis_agent/jarvis.py

@@ -19,6 +19,8 @@ from jarvis.jarvis_utils.config import (
     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
@@ -26,10 +28,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 助手")
 
 
@@ -187,9 +216,9 @@ def handle_interactive_config_option(
         return True
 
 
-def handle_backup_option(backup: bool) -> bool:
+def handle_backup_option(backup_dir_path: Optional[str]) -> bool:
     """处理数据备份选项，返回是否已处理并需提前结束。"""
-    if not backup:
+    if backup_dir_path is None:
         return False
 
     init_env("", config_file=None)
@@ -198,7 +227,8 @@ def handle_backup_option(backup: bool) -> bool:
         PrettyOutput.print(f"数据目录不存在: {data_dir}", OutputType.ERROR)
         return True
 
-    backup_dir = Path(os.path.expanduser("~/jarvis_backups"))
+    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")
@@ -290,6 +320,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(
@@ -632,12 +665,23 @@ def run_cli(
         "--disable-methodology-analysis",
         help="禁用方法论和任务分析（覆盖配置文件设置）",
     ),
-    backup_data: bool = typer.Option(
-        False, "--backup-data", help="备份 Jarvis 数据目录 (~/.jarvis)"
+    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 服务端口"),
+    stop: bool = typer.Option(False, "--stop", help="停止后台 Web 服务（需与 --web 一起使用）"),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -646,6 +690,37 @@ 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()):
+        PrettyOutput.print(
+            "非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。",
+            OutputType.ERROR,
+        )
+        raise typer.Exit(code=2)
+
     # 处理数据备份
     if handle_backup_option(backup_data):
         return
@@ -672,30 +747,319 @@ 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）
-    try_switch_to_jca_if_git_repo(
-        model_group, tool_group, config_file, restore_session, task
-    )
+    if not non_interactive and not web:
+        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)
+    # 非交互模式下跳过内置角色/配置选择
+    if not non_interactive and not web:
+        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:
+            try:
+                from jarvis.jarvis_agent.web_bridge import web_multiline_input, web_user_confirm
+                extra_kwargs["multiline_inputer"] = web_multiline_input
+                extra_kwargs["confirm_callback"] = web_user_confirm
+            except Exception as e:
+                PrettyOutput.print(f"Web 模式初始化失败（加载 Web 桥接模块）: {e}", OutputType.ERROR)
+                raise typer.Exit(code=1)
+
         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,
+            **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
+                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

jarvis/jarvis_agent/main.py

@@ -9,6 +9,7 @@ from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_utils.input import get_multiline_input
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import init_env
+from jarvis.jarvis_utils.config import set_config
 
 app = typer.Typer(help="Jarvis AI 助手")
 
@@ -46,16 +47,45 @@ def cli(
         None, "-c", "--agent-definition", help="代理定义文件路径"
     ),
     task: Optional[str] = typer.Option(None, "-T", "--task", help="初始任务内容"),
-
+    
     model_group: Optional[str] = typer.Option(
         None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
     ),
+    non_interactive: bool = typer.Option(
+        False, "-n", "--non-interactive", help="启用非交互模式：用户无法与命令交互，脚本执行超时限制为5分钟"
+    ),
 ):
     """Main entry point for Jarvis agent"""
-    # Initialize environment
+    # CLI 标志：非交互模式（不依赖配置文件）
+    if non_interactive:
+        try:
+            os.environ["JARVIS_NON_INTERACTIVE"] = "true"
+        except Exception:
+            pass
+        try:
+            set_config("JARVIS_NON_INTERACTIVE", True)
+        except Exception:
+            pass
+    # 非交互模式要求从命令行传入任务
+    if non_interactive and not (task and str(task).strip()):
+        PrettyOutput.print(
+            "非交互模式已启用：必须使用 --task 传入任务内容，因多行输入不可用。",
+            OutputType.ERROR,
+        )
+        raise typer.Exit(code=2)
+    # Initialize环境
     init_env(
         "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file
     )
+    # 在初始化环境后同步 CLI 选项到全局配置，避免被 init_env 覆盖
+    try:
+        if model_group:
+            set_config("JARVIS_LLM_GROUP", str(model_group))
+        if non_interactive:
+            set_config("JARVIS_NON_INTERACTIVE", True)
+    except Exception:
+        # 静默忽略同步异常，不影响主流程
+        pass
 
     # Load configuration
     config = load_config(agent_definition) if agent_definition else {}