refactor(agent): Improve app with logging and args

- Add agent_logger for dedicated logging
- Add --ws-uri argument with env var support
- Use aio_run for event loop management
- Add logging configuration (colored, simple, severity)
- Translate Korean messages to English
- Remove deprecated worker app module

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: osom8979

cvp/apps/__init__.py

@@ -9,8 +9,7 @@
 from cvp.apps.cli import cli_main
 from cvp.apps.player import player_main
 from cvp.apps.tester import tester_main
-from cvp.apps.worker import worker_main
-from cvp.arguments import CMD_AGENT, CMD_CLI, CMD_PLAYER, CMD_TESTER, CMD_WORKER
+from cvp.arguments import CMD_AGENT, CMD_CLI, CMD_PLAYER, CMD_TESTER
 from cvp.context.autofixer import AutoFixerError
 from cvp.logging.loggers import logger
 
@@ -22,7 +21,6 @@ def cmd_apps() -> Dict[str, Callable[[Namespace], None]]:
         CMD_CLI: cli_main,
         CMD_PLAYER: player_main,
         CMD_TESTER: tester_main,
-        CMD_WORKER: worker_main,
     }
 
 

cvp/apps/agent/__init__.py

@@ -3,16 +3,67 @@
 from argparse import Namespace
 
 from cvp.context.context import Context
+from cvp.logging.loggers import agent_logger as logger
+from cvp.logging.logging import (
+    SEVERITY_NAME_DEBUG,
+    SEVERITY_NAME_WARNING,
+    add_default_colored_logging,
+    add_simple_logging,
+    convert_level_number,
+    set_asyncio_level,
+)
+from cvp.variables import SLOW_CALLBACK_DURATION
 
 
 def agent_main(args: Namespace) -> None:
     assert isinstance(args.home, str)
+    assert isinstance(args.ws_uri, str)
+    assert isinstance(args.colored_logging, bool)
+    assert isinstance(args.simple_logging, bool)
+    assert isinstance(args.logging_step, int)
+    assert isinstance(args.logging_severity, str)
+    assert isinstance(args.use_uvloop, bool)
+    assert isinstance(args.debug, bool)
+    assert isinstance(args.verbose, int)
+    assert isinstance(args.D, bool)
+    assert isinstance(args.opts, list)
 
-    context = Context(args.home)
+    if args.D:
+        args.colored_logging = True
+        args.simple_logging = False
+        args.debug = True
+        args.verbose = 2
+
+    if args.debug:
+        args.logging_severity = SEVERITY_NAME_DEBUG
+
+    level = convert_level_number(args.logging_severity)
+    logger.setLevel(level)
+
+    if args.colored_logging:
+        assert not args.simple_logging
+        add_default_colored_logging(logger.name)
+    elif args.simple_logging:
+        assert not args.colored_logging
+        add_simple_logging(logger.name)
+
+    asyncio_severity = SEVERITY_NAME_DEBUG if args.debug else SEVERITY_NAME_WARNING
+    asyncio_level = convert_level_number(asyncio_severity)
+    set_asyncio_level(asyncio_level)
+
+    context = Context(args.home, detect_opengl=False)
 
     # [IMPORTANT]
     # Do not change the import order!
     from cvp.apps.agent.app import AgentApplication
 
-    app = AgentApplication(context)
+    app = AgentApplication(
+        context=context,
+        ws_uri=args.ws_uri,
+        logging_step=args.logging_step,
+        slow_callback_duration=SLOW_CALLBACK_DURATION,
+        use_uvloop=args.use_uvloop,
+        debug=args.debug,
+        verbose=args.verbose,
+    )
     app.start()

cvp/apps/agent/app.py

@@ -1,63 +1,51 @@
 # -*- coding: utf-8 -*-
 
-import asyncio
-from typing import Optional
+from asyncio import get_running_loop
 
+from cvp.aio.run import aio_run
 from cvp.context.context import Context
-from cvp.logging.loggers import logger
+from cvp.logging.loggers import agent_logger as logger
+from cvp.variables import AGENT_WS_URI, LOGGING_STEP, SLOW_CALLBACK_DURATION
 from cvp.ws.asyncio.client import WebSocketClient
 
 
 class AgentApplication:
-    def __init__(self, context: Context):
+    def __init__(
+        self,
+        context: Context,
+        ws_uri: str = AGENT_WS_URI,
+        logging_step=LOGGING_STEP,
+        slow_callback_duration=SLOW_CALLBACK_DURATION,
+        use_uvloop=False,
+        debug=False,
+        verbose=0,
+    ):
         self._context = context
-        self._ws_client: Optional[WebSocketClient] = None
-        self._loop: Optional[asyncio.AbstractEventLoop] = None
-
-    def start(self) -> None:
-        # WebSocket URI 설정 (환경 변수나 설정 파일에서 가져올 수 있음)
-        ws_uri = "ws://localhost:8765"  # 기본값
-
-        # 설정에서 URI 가져오기 (있다면)
-        if hasattr(self._context, "config"):
-            ws_uri = getattr(self._context.config, "agent_ws_uri", ws_uri)
-
-        logger.info(f"Agent 애플리케이션 시작: {ws_uri}")
-
-        # WebSocket 클라이언트 생성
         self._ws_client = WebSocketClient(uri=ws_uri)
+        self._logging_step = logging_step
+        self._slow_callback_duration = slow_callback_duration
+        self._use_uvloop = use_uvloop
+        self._debug = debug
+        self._verbose = verbose
 
-        # 이벤트 루프 생성 및 실행
-        try:
-            self._loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self._loop)
+    async def on_main(self) -> None:
+        logger.info(f"Starting agent application: {self._ws_client.uri}")
 
-            # WebSocket 클라이언트 시작
-            self._loop.run_until_complete(self._run())
-        except KeyboardInterrupt:
-            logger.info("Agent 애플리케이션 중지 요청")
-        finally:
-            self._cleanup()
-
-    async def _run(self) -> None:
-        if not self._ws_client:
-            logger.error("WebSocket 클라이언트가 초기화되지 않았습니다")
-            return
+        loop = get_running_loop()
+        loop.slow_callback_duration = self._slow_callback_duration
+        loop.set_debug(self._debug)
 
         try:
-            # WebSocket 클라이언트 시작
             await self._ws_client.start()
         except Exception as e:
-            logger.error(f"Agent 실행 중 오류: {e}")
+            logger.error(f"Agent runtime error: {e}")
             raise
+        finally:
+            await self._ws_client.stop()
+            logger.info("Agent application stopped")
 
-    def _cleanup(self) -> None:
-        if self._ws_client:
-            # WebSocket 클라이언트 중지
-            if self._loop and not self._loop.is_closed():
-                self._loop.run_until_complete(self._ws_client.stop())
-
-        if self._loop:
-            self._loop.close()
-
-        logger.info("Agent 애플리케이션 종료")
+    def start(self) -> None:
+        try:
+            aio_run(self.on_main(), self._use_uvloop)
+        except (KeyboardInterrupt, InterruptedError):
+            logger.warning("Interrupt signal detected")

cvp/apps/worker/__init__.py

@@ -9,6 +9,7 @@
 from cvp.logging.logging import SEVERITIES, SEVERITY_NAME_INFO
 from cvp.system.environ import get_typed_environ_value as get_eval
 from cvp.system.environ_keys import (
+    CVP_AGENT_WS_URI,
     CVP_COLORED_LOGGING,
     CVP_DEBUG,
     CVP_DOTENV_PATH,
@@ -23,6 +24,7 @@
     SDL_VIDEO_X11_FORCE_EGL,
 )
 from cvp.variables import (
+    AGENT_WS_URI,
     CVP_HOME_DIRNAME,
     DOTENV_LOCAL_FILENAME,
     FONT_DEFAULT_NAME,
@@ -41,13 +43,6 @@
   {PROG} {CMD_PLAYER}
 """
 
-CMD_WORKER: Final[str] = "worker"
-CMD_WORKER_HELP: Final[str] = "The flow graph for worker"
-CMD_WORKER_EPILOG = f"""
-Simply usage:
-  {PROG} {CMD_WORKER}
-"""
-
 CMD_AGENT: Final[str] = "agent"
 CMD_AGENT_HELP: Final[str] = "Background agent"
 CMD_AGENT_EPILOG = f"""
@@ -69,7 +64,7 @@
   {PROG} {CMD_TESTER}
 """
 
-CMDS: Final[Sequence[str]] = CMD_PLAYER, CMD_WORKER, CMD_AGENT, CMD_CLI, CMD_TESTER
+CMDS: Final[Sequence[str]] = CMD_PLAYER, CMD_AGENT, CMD_CLI, CMD_TESTER
 DEFAULT_CMD: Final[str] = CMD_PLAYER
 
 DEFAULT_SEVERITY: Final[str] = SEVERITY_NAME_INFO
@@ -209,16 +204,24 @@ def add_player_parser(subparsers) -> None:
     assert isinstance(parser, ArgumentParser)
 
 
-def add_worker_parser(subparsers) -> None:
+def add_agent_parser(subparsers) -> None:
     # noinspection SpellCheckingInspection
     parser = subparsers.add_parser(
-        name=CMD_WORKER,
-        help=CMD_WORKER_HELP,
+        name=CMD_AGENT,
+        help=CMD_AGENT_HELP,
         formatter_class=RawDescriptionHelpFormatter,
-        epilog=CMD_WORKER_EPILOG,
+        epilog=CMD_AGENT_EPILOG,
     )
     assert isinstance(parser, ArgumentParser)
 
+    parser.add_argument(
+        "--ws-uri",
+        type=str,
+        default=get_eval(CVP_AGENT_WS_URI, AGENT_WS_URI),
+        metavar="uri",
+        help=f"WebSocket server URI (default: '{AGENT_WS_URI}')",
+    )
+
     logging_group = parser.add_mutually_exclusive_group()
     logging_group.add_argument(
         "--colored-logging",
@@ -282,17 +285,6 @@ def add_worker_parser(subparsers) -> None:
     )
 
 
-def add_agent_parser(subparsers) -> None:
-    # noinspection SpellCheckingInspection
-    parser = subparsers.add_parser(
-        name=CMD_AGENT,
-        help=CMD_AGENT_HELP,
-        formatter_class=RawDescriptionHelpFormatter,
-        epilog=CMD_AGENT_EPILOG,
-    )
-    assert isinstance(parser, ArgumentParser)
-
-
 def add_cli_parser(subparsers) -> None:
     # noinspection SpellCheckingInspection
     parser = subparsers.add_parser(
@@ -342,7 +334,6 @@ def default_argument_parser() -> ArgumentParser:
 
     subparsers = parser.add_subparsers(dest="cmd")
     add_player_parser(subparsers)
-    add_worker_parser(subparsers)
     add_agent_parser(subparsers)
     add_cli_parser(subparsers)
     add_tester_parser(subparsers)

cvp/apps/worker/app.py

@@ -6,6 +6,7 @@
 
 logger = getLogger(names.CVP_LOGGER_NAME)
 
+agent_logger = getLogger(names.CVP_AGENT_LOGGER_NAME)
 canvas_logger = getLogger(names.CVP_CANVAS_LOGGER_NAME)
 chat_logger = getLogger(names.CVP_CHAT_LOGGER_NAME)
 download_logger = getLogger(names.CVP_DOWNLOAD_LOGGER_NAME)