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

jarvis/jarvis_agent/web_server.py

@@ -10,23 +10,27 @@
 - 注入 web_multiline_input 与 web_user_confirm 到 Agent，使输入与确认经由浏览器完成
 - 启动本服务，前端通过页面与 Agent 交互
 """
+
 from __future__ import annotations
 
+from jarvis.jarvis_utils.output import PrettyOutput
+
 import asyncio
+import atexit
 import json
 import os
 import signal
-import atexit
 from pathlib import Path
-from typing import Any, Dict, Callable, Optional, List
+from typing import Any, Callable, Dict, List, Optional
 
 import uvicorn
 from fastapi import FastAPI, WebSocket, WebSocketDisconnect
-from fastapi.responses import HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
 
 from jarvis.jarvis_agent.web_bridge import WebBridge
-from jarvis.jarvis_utils.globals import set_interrupt, console
+from jarvis.jarvis_utils.globals import console, set_interrupt
+
 
 # ---------------------------
 # 应用与页面
@@ -245,10 +249,13 @@ writeLine('消息解析失败: ' + e);
 
     return app
 
+
 # ---------------------------
 # WebSocket 端点
 # ---------------------------
-async def _ws_sender_loop(ws: WebSocket, queue: "asyncio.Queue[Dict[str, Any]]") -> None:
+async def _ws_sender_loop(
+    ws: WebSocket, queue: "asyncio.Queue[Dict[str, Any]]"
+) -> None:
     try:
         while True:
             payload = await queue.get()
@@ -257,20 +264,28 @@ async def _ws_sender_loop(ws: WebSocket, queue: "asyncio.Queue[Dict[str, Any]]")
         # 发送循环异常即退出
         pass
 
-def _make_sender(queue: "asyncio.Queue[Dict[str, Any]]") -> Callable[[Dict[str, Any]], None]:
+
+def _make_sender(
+    queue: "asyncio.Queue[Dict[str, Any]]",
+) -> Callable[[Dict[str, Any]], None]:
     # 同步函数，供 WebBridge 注册；将消息放入异步队列，由协程发送
     def _sender(payload: Dict[str, Any]) -> None:
         try:
             queue.put_nowait(payload)
         except Exception:
             pass
+
     return _sender
 
-def _make_sender_filtered(queue: "asyncio.Queue[Dict[str, Any]]", allowed_types: Optional[list[str]] = None) -> Callable[[Dict[str, Any]], None]:
+
+def _make_sender_filtered(
+    queue: "asyncio.Queue[Dict[str, Any]]", allowed_types: Optional[list[str]] = None
+) -> Callable[[Dict[str, Any]], None]:
     """
     过滤版 sender：仅将指定类型的payload放入队列（用于单独的STDIO通道）。
     """
     allowed = set(allowed_types or [])
+
     def _sender(payload: Dict[str, Any]) -> None:
         try:
             ptype = payload.get("type")
@@ -278,8 +293,10 @@ def _make_sender_filtered(queue: "asyncio.Queue[Dict[str, Any]]", allowed_types:
                 queue.put_nowait(payload)
         except Exception:
             pass
+
     return _sender
 
+
 def _run_and_notify(agent: Any, text: str) -> None:
     try:
         agent.run(text)
@@ -289,14 +306,20 @@ def _run_and_notify(agent: Any, text: str) -> None:
         except Exception:
             pass
 
-def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, launch_command: Optional[List[str]] = None) -> None:
+
+def start_web_server(
+    agent: Any,
+    host: str = "127.0.0.1",
+    port: int = 8765,
+    launch_command: Optional[List[str]] = None,
+) -> None:
     """
     启动Web服务，并将Agent绑定到应用上下文。
     - agent: 现有的 Agent 实例（已完成初始化）
     - host: Web 服务主机地址
     - port: Web 服务端口
     - launch_command: 交互式终端启动命令（列表格式，如 ["jvs", "--task", "xxx"]），
-                      如果为 None，则从环境变量 JARVIS_WEB_LAUNCH_JSON 读取
+                      如果为 None，则从环境变量 web_launch_json 读取
     """
     app = _build_app()
     app.state.agent = agent  # 供 WS 端点调用
@@ -319,7 +342,14 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
         bridge.add_client(sender)
         send_task = asyncio.create_task(_ws_sender_loop(ws, queue))
         try:
-            await ws.send_text(json.dumps({"type": "output", "payload": {"text": "STDIO 通道已就绪", "output_type": "INFO"}}))
+            await ws.send_text(
+                json.dumps(
+                    {
+                        "type": "output",
+                        "payload": {"text": "STDIO 通道已就绪", "output_type": "INFO"},
+                    }
+                )
+            )
         except Exception:
             pass
         try:
@@ -334,6 +364,7 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                 if mtype == "stdin":
                     try:
                         from jarvis.jarvis_agent.stdio_redirect import feed_web_stdin
+
                         text = data.get("data", "")
                         if isinstance(text, str) and text:
                             feed_web_stdin(text)
@@ -372,7 +403,9 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                     try:
                         set_interrupt(True)
                         # 可选：发送回执
-                        await ws.send_text(json.dumps({"type": "ack", "cmd": "interrupt"}))
+                        await ws.send_text(
+                            json.dumps({"type": "ack", "cmd": "interrupt"})
+                        )
                     except Exception:
                         pass
                 elif mtype == "resize":
@@ -411,9 +444,20 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
         await ws.accept()
         # 仅在非 Windows 平台提供 PTY 功能
         import sys as _sys
+
         if _sys.platform == "win32":
             try:
-                await ws.send_text(json.dumps({"type": "output", "payload": {"text": "当前平台不支持交互式终端（PTY）", "output_type": "ERROR"}}))
+                await ws.send_text(
+                    json.dumps(
+                        {
+                            "type": "output",
+                            "payload": {
+                                "text": "当前平台不支持交互式终端（PTY）",
+                                "output_type": "ERROR",
+                            },
+                        }
+                    )
+                )
             except Exception:
                 pass
             try:
@@ -423,15 +467,26 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
             return
 
         import os as _os
+
         try:
-            import pty as _pty
             import fcntl as _fcntl
+            import pty as _pty
             import select as _select
-            import termios as _termios
             import struct as _struct
+            import termios as _termios
         except Exception:
             try:
-                await ws.send_text(json.dumps({"type": "output", "payload": {"text": "服务端缺少 PTY 相关依赖，无法启动交互式终端", "output_type": "ERROR"}}))
+                await ws.send_text(
+                    json.dumps(
+                        {
+                            "type": "output",
+                            "payload": {
+                                "text": "服务端缺少 PTY 相关依赖，无法启动交互式终端",
+                                "output_type": "ERROR",
+                            },
+                        }
+                    )
+                )
             except Exception:
                 pass
             try:
@@ -456,24 +511,29 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
         # 会话结束后等待用户按回车再重启
         waiting_for_ack = False
         ack_event = asyncio.Event()
-        
+
         # 在 fork 前获取启动命令（避免在子进程中访问 app.state）
         _launch_cmd = None
         try:
             if hasattr(app.state, "launch_command") and app.state.launch_command:
                 _launch_cmd = app.state.launch_command
                 # 调试输出
-                if _os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
-                    print(f"🔍 Web服务器: 使用传入的启动命令: {_launch_cmd}")
+                if _os.environ.get("debug_web_launch_cmd") == "1":
+                    PrettyOutput.auto_print(
+                        f"🔍 Web服务器: 使用传入的启动命令: {_launch_cmd}"
+                    )
             else:
                 # 回退到环境变量
                 import json as _json
-                _cmd_json = _os.environ.get("JARVIS_WEB_LAUNCH_JSON", "")
+
+                _cmd_json = _os.environ.get("web_launch_json", "")
                 if _cmd_json:
                     try:
                         _launch_cmd = _json.loads(_cmd_json)
-                        if _os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
-                            print(f"🔍 Web服务器: 从环境变量读取启动命令: {_launch_cmd}")
+                        if _os.environ.get("debug_web_launch_cmd") == "1":
+                            PrettyOutput.auto_print(
+                                f"🔍 Web服务器: 从环境变量读取启动命令: {_launch_cmd}"
+                            )
                     except Exception:
                         _launch_cmd = None
         except Exception:
@@ -487,16 +547,21 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                     # 子进程：执行启动命令，失败时回退到系统 shell
                     # 使用在 fork 前获取的命令
                     _argv = _launch_cmd
-                    
+
                     # 如果获取到有效命令，执行它
-                    if _argv and isinstance(_argv, list) and len(_argv) > 0 and isinstance(_argv[0], str):
+                    if (
+                        _argv
+                        and isinstance(_argv, list)
+                        and len(_argv) > 0
+                        and isinstance(_argv[0], str)
+                    ):
                         try:
-                            if _os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
-                                print(f"🔍 子进程: 执行命令: {_argv}")
+                            if _os.environ.get("debug_web_launch_cmd") == "1":
+                                PrettyOutput.auto_print(f"🔍 子进程: 执行命令: {_argv}")
                             _os.execvp(_argv[0], _argv)
                         except Exception as e:
-                            if _os.environ.get("JARVIS_DEBUG_WEB_LAUNCH_CMD") == "1":
-                                print(f"⚠️ 子进程: 执行命令失败: {e}")
+                            if _os.environ.get("debug_web_launch_cmd") == "1":
+                                PrettyOutput.auto_print(f"⚠️ 子进程: 执行命令失败: {e}")
                             pass
                     # 若未配置或执行失败，回退到 /bin/bash 或 /bin/sh
                     try:
@@ -530,7 +595,17 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
         ok = _spawn_jvs_session()
         if not ok:
             try:
-                await ws.send_text(json.dumps({"type": "output", "payload": {"text": "启动交互式终端失败", "output_type": "ERROR"}}))
+                await ws.send_text(
+                    json.dumps(
+                        {
+                            "type": "output",
+                            "payload": {
+                                "text": "启动交互式终端失败",
+                                "output_type": "ERROR",
+                            },
+                        }
+                    )
+                )
             except Exception:
                 pass
             try:
@@ -555,7 +630,14 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                                 waiting_for_ack = False
                                 if _spawn_jvs_session():
                                     try:
-                                        await ws.send_text(json.dumps({"type": "stdio", "text": "\r\njvs 会话已重启\r\n"}))
+                                        await ws.send_text(
+                                            json.dumps(
+                                                {
+                                                    "type": "stdio",
+                                                    "text": "\r\njvs 会话已重启\r\n",
+                                                }
+                                            )
+                                        )
                                     except Exception:
                                         pass
                                     fd = session.get("master_fd")
@@ -568,7 +650,14 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                         # 非确认流程：自动重启
                         if _spawn_jvs_session():
                             try:
-                                await ws.send_text(json.dumps({"type": "stdio", "text": "\r\njvs 会话已重启\r\n"}))
+                                await ws.send_text(
+                                    json.dumps(
+                                        {
+                                            "type": "stdio",
+                                            "text": "\r\njvs 会话已重启\r\n",
+                                        }
+                                    )
+                                )
                             except Exception:
                                 pass
                             fd = session.get("master_fd")
@@ -591,7 +680,14 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                             data = b""
                         if data:
                             try:
-                                await ws.send_text(json.dumps({"type": "stdio", "text": data.decode(errors="ignore")}))
+                                await ws.send_text(
+                                    json.dumps(
+                                        {
+                                            "type": "stdio",
+                                            "text": data.decode(errors="ignore"),
+                                        }
+                                    )
+                                )
                             except Exception:
                                 break
                         else:
@@ -609,7 +705,14 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                                 # 标记等待用户回车，并提示
                                 waiting_for_ack = True
                                 try:
-                                    await ws.send_text(json.dumps({"type": "stdio", "text": "\r\nAgent 已结束。按回车继续，系统将重启新的 Agent。\r\n> "}))
+                                    await ws.send_text(
+                                        json.dumps(
+                                            {
+                                                "type": "stdio",
+                                                "text": "\r\nAgent 已结束。按回车继续，系统将重启新的 Agent。\r\n> ",
+                                            }
+                                        )
+                                    )
                                 except Exception:
                                     pass
                                 # 不立即重启，等待顶部 fd None 分支在收到回车后处理
@@ -645,7 +748,17 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
             pass
         # 发送就绪提示
         try:
-            await ws.send_text(json.dumps({"type": "output", "payload": {"text": "交互式终端已就绪（PTY）", "output_type": "INFO"}}))
+            await ws.send_text(
+                json.dumps(
+                    {
+                        "type": "output",
+                        "payload": {
+                            "text": "交互式终端已就绪（PTY）",
+                            "output_type": "INFO",
+                        },
+                    }
+                )
+            )
         except Exception:
             pass
 
@@ -672,12 +785,22 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                                 else:
                                     # 非回车输入时轻提示
                                     try:
-                                        await ws.send_text(json.dumps({"type": "stdio", "text": "\r\n按回车继续。\r\n> "}))
+                                        await ws.send_text(
+                                            json.dumps(
+                                                {
+                                                    "type": "stdio",
+                                                    "text": "\r\n按回车继续。\r\n> ",
+                                                }
+                                            )
+                                        )
                                     except Exception:
                                         pass
                             else:
                                 # 原样写入（保留控制字符）；前端可按需发送回车
-                                _os.write(session.get("master_fd") or -1, text.encode(errors="ignore"))
+                                _os.write(
+                                    session.get("master_fd") or -1,
+                                    text.encode(errors="ignore"),
+                                )
                     except Exception:
                         pass
                 elif mtype == "resize":
@@ -723,6 +846,7 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                 pid_val = session.get("pid")
                 if isinstance(pid_val, int):
                     import signal as _signal
+
                     try:
                         _os.kill(pid_val, _signal.SIGTERM)
                     except Exception:
@@ -734,7 +858,7 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
             except Exception:
                 pass
 
-    print(f"✅ 启动 Jarvis Web 服务: http://{host}:{port}")
+    PrettyOutput.auto_print(f"✅ 启动 Jarvis Web 服务: http://{host}:{port}")
     # 在服务端进程内也写入并维护 PID 文件，增强可检测性与可清理性
     try:
         pidfile = Path(os.path.expanduser("~/.jarvis")) / f"jarvis_web_{port}.pid"
@@ -746,16 +870,19 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
             pidfile.write_text(str(os.getpid()), encoding="utf-8")
         except Exception:
             pass
+
         # 退出时清理 PID 文件
         def _cleanup_pidfile() -> None:
             try:
                 pidfile.unlink(missing_ok=True)
             except Exception:
                 pass
+
         try:
             atexit.register(_cleanup_pidfile)
         except Exception:
             pass
+
         # 处理 SIGTERM/SIGINT，清理后退出
         def _signal_handler(signum: int, frame: Any) -> None:
             try:
@@ -765,6 +892,7 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
                     os._exit(0)
                 except Exception:
                     pass
+
         try:
             signal.signal(signal.SIGTERM, _signal_handler)
         except Exception:
@@ -777,6 +905,7 @@ def start_web_server(agent: Any, host: str = "127.0.0.1", port: int = 8765, laun
         pass
     # 配置 uvicorn 日志级别，隐藏连接信息和访问日志
     import logging
+
     # 禁用 uvicorn 的访问日志
     logging.getLogger("uvicorn.access").setLevel(logging.WARNING)
     # 禁用 uvicorn 的常规日志（连接信息等）

jarvis/jarvis_c2rust/__init__.py

@@ -23,4 +23,4 @@ Jarvis C2Rust 工具集。
 - 所有路径均推荐使用 <project_root>/.jarvis/c2rust 下的标准文件名，便于断点续跑与复用。
 """
 
-__all__ = ["scanner", "optimizer"]
+__all__ = ["scanner", "optimizer"]