codebuff-agent 2.1.74__py3-none-any.whl

jupyter_ext/idle_monitor.py

@@ -0,0 +1,346 @@
+"""
+Server-side Idle Monitor.
+
+브라우저가 닫혀도 커널/터미널 활동을 감지하여 idle timeout을 서버에서 처리.
+Jupyter Server의 커널/터미널 매니저를 통해 마지막 활동 시간을 추적한다.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+from typing import Optional
+
+logger = logging.getLogger("ServerApp")
+
+# 기본 idle timeout: 60분
+DEFAULT_IDLE_TIMEOUT_SECONDS = 60 * 60
+
+# 서버 체크 주기: 30초
+CHECK_INTERVAL_SECONDS = 30
+
+# SageMaker 메타데이터 경로
+SAGEMAKER_METADATA_PATH = "/opt/ml/metadata/resource-metadata.json"
+
+
+def _is_sagemaker() -> bool:
+    """SageMaker 환경인지 판별."""
+    return bool(os.environ.get("SAGEMAKER_SPACE_NAME"))
+
+
+class ServerIdleMonitor:
+    """서버 사이드 유휴 상태 모니터."""
+
+    def __init__(self, server_app):
+        self.server_app = server_app
+        self.last_activity_time = time.time()
+        self._task: Optional[asyncio.Task] = None
+        self._shutdown_triggered = False
+        self._sagemaker = _is_sagemaker()
+
+        # idle timeout 설정 로드
+        self.idle_timeout_seconds = self._load_timeout()
+
+        # 환경변수 (shutdown API용)
+        self.hdsp_env = os.environ.get("HDSP_ENV")
+        self.project_id = os.environ.get("HDSP_PRJ_ID")
+        self.user_id = os.environ.get("JUPYTERHUB_USER")
+
+    def _load_timeout(self) -> int:
+        """config에서 idle timeout 로드. 최대 1시간."""
+        try:
+            from codebuff_core.managers.config_manager import get_config_manager
+
+            cm = get_config_manager()
+            config = cm.get_config()
+            timeout = config.get("idleTimeout")
+            if isinstance(timeout, (int, float)) and timeout > 0:
+                return min(int(timeout), DEFAULT_IDLE_TIMEOUT_SECONDS)
+        except Exception:
+            pass
+        return DEFAULT_IDLE_TIMEOUT_SECONDS
+
+    def start(self):
+        """모니터링 시작."""
+        if self.idle_timeout_seconds <= 0:
+            logger.info("[ServerIdleMonitor] Disabled (timeout=0)")
+            return
+
+        # SageMaker는 환경변수 없어도 시작 가능
+        if not self._sagemaker and not (
+            self.hdsp_env and self.project_id and self.user_id
+        ):
+            logger.info(
+                "[ServerIdleMonitor] Disabled (missing HDSP_ENV/HDSP_PRJ_ID/JUPYTERHUB_USER)"
+            )
+            return
+
+        self._task = asyncio.ensure_future(self._monitor_loop())
+        logger.info(
+            "[ServerIdleMonitor] Started (sagemaker=%s, timeout=%ds, interval=%ds)",
+            self._sagemaker,
+            self.idle_timeout_seconds,
+            CHECK_INTERVAL_SECONDS,
+        )
+
+    def stop(self):
+        """모니터링 중지."""
+        if self._task and not self._task.done():
+            self._task.cancel()
+            logger.info("[ServerIdleMonitor] Stopped")
+
+    def reset(self):
+        """활동 감지 시 타이머 리셋 (HTTP 요청 시 호출)."""
+        self.last_activity_time = time.time()
+
+    def get_idle_status(self) -> dict:
+        """현재 idle 상태 반환 (API 응답용)."""
+        kernel_last = self._check_kernel_activity()
+        terminal_last = self._check_terminal_activity()
+        latest = max(self.last_activity_time, kernel_last, terminal_last)
+        idle_seconds = time.time() - latest
+        return {
+            "idle": idle_seconds >= self.idle_timeout_seconds,
+            "idle_seconds": round(idle_seconds),
+            "timeout_seconds": self.idle_timeout_seconds,
+        }
+
+    def _check_kernel_activity(self) -> float:
+        """커널 매니저에서 마지막 활동 시간 조회. epoch 반환."""
+        last = 0.0
+        try:
+            km = self.server_app.kernel_manager
+            for kid in km.list_kernel_ids():
+                kernel = km.get_kernel(kid)
+                # last_activity는 datetime 객체
+                if hasattr(kernel, "last_activity") and kernel.last_activity:
+                    ts = kernel.last_activity.timestamp()
+                    if ts > last:
+                        last = ts
+                # execution_state로 busy 체크
+                if (
+                    hasattr(kernel, "execution_state")
+                    and kernel.execution_state == "busy"
+                ):
+                    return time.time()  # busy면 지금 활동 중
+        except Exception as e:
+            logger.debug("[ServerIdleMonitor] Kernel check error: %s", e)
+        return last
+
+    def _check_terminal_activity(self) -> float:
+        """터미널 매니저에서 마지막 활동 시간 조회. 자식 프로세스도 감지."""
+        last = 0.0
+        try:
+            tm = self.server_app.web_app.settings.get("terminal_manager")
+            if tm is None:
+                return last
+
+            # terminado의 terminals dict에서 직접 순회
+            terminals = getattr(tm, "terminals", None)
+            if not terminals:
+                logger.info(
+                    "[ServerIdleMonitor] No tm.terminals found (type=%s)",
+                    type(tm).__name__,
+                )
+                return last
+
+            for term_name, term_obj in terminals.items():
+                # last_activity 확인 (REST model 대신 직접)
+                try:
+                    term_model = tm.get(term_name)
+                    if isinstance(term_model, dict):
+                        la = term_model.get("last_activity")
+                        if la and hasattr(la, "timestamp"):
+                            ts = la.timestamp()
+                            if ts > last:
+                                last = ts
+                except Exception:
+                    pass
+
+                # PTY 자식 프로세스 확인
+                if self._terminal_has_running_process(term_obj, term_name):
+                    return time.time()
+
+        except Exception as e:
+            logger.warning("[ServerIdleMonitor] Terminal check error: %s", e)
+        return last
+
+    def _terminal_has_running_process(self, term, term_name: str = "") -> bool:
+        """터미널의 쉘에 자식 프로세스가 실행 중인지 확인."""
+        try:
+            import psutil
+
+            ptyproc = getattr(term, "ptyproc", None)
+            if ptyproc is None:
+                logger.info(
+                    "[ServerIdleMonitor] Terminal '%s': no ptyproc attr", term_name
+                )
+                return False
+
+            pid = getattr(ptyproc, "pid", None)
+            if pid is None:
+                logger.info(
+                    "[ServerIdleMonitor] Terminal '%s': ptyproc has no pid", term_name
+                )
+                return False
+
+            if not ptyproc.isalive():
+                return False
+
+            proc = psutil.Process(pid)
+            children = proc.children(recursive=True)
+            if children:
+                child_info = [(c.pid, c.name()) for c in children]
+                logger.info(
+                    "[ServerIdleMonitor] Terminal '%s' (pid=%d) has %d child(ren): %s",
+                    term_name,
+                    pid,
+                    len(children),
+                    child_info,
+                )
+                return True
+            return False
+        except Exception as e:
+            logger.warning(
+                "[ServerIdleMonitor] Process check error for '%s': %s", term_name, e
+            )
+            return False
+
+    async def _monitor_loop(self):
+        """주기적으로 idle 상태를 체크."""
+        try:
+            while True:
+                await asyncio.sleep(CHECK_INTERVAL_SECONDS)
+
+                if self._shutdown_triggered:
+                    break
+
+                # 커널/터미널에서 마지막 활동 시간 조회
+                now = time.time()
+                kernel_last = self._check_kernel_activity()
+                terminal_last = self._check_terminal_activity()
+
+                # HTTP 요청 활동, 커널 활동, 터미널 활동 중 가장 최근
+                latest_activity = max(
+                    self.last_activity_time, kernel_last, terminal_last
+                )
+
+                idle_seconds = now - latest_activity
+
+                # 60초마다 상태 로깅
+                if int(idle_seconds) % 60 < CHECK_INTERVAL_SECONDS:
+                    logger.info(
+                        "[ServerIdleMonitor] idle=%.0fs/%.0fs, http=%.0fs ago, kernel=%.0fs ago, terminal=%.0fs ago",
+                        idle_seconds,
+                        self.idle_timeout_seconds,
+                        now - self.last_activity_time,
+                        now - kernel_last if kernel_last > 0 else -1,
+                        now - terminal_last if terminal_last > 0 else -1,
+                    )
+
+                if idle_seconds >= self.idle_timeout_seconds:
+                    logger.info(
+                        "[ServerIdleMonitor] Idle timeout reached (%.0fs idle). Triggering shutdown.",
+                        idle_seconds,
+                    )
+                    self._shutdown_triggered = True
+                    from .log_paths import write_idle_shutdown_log
+
+                    write_idle_shutdown_log(
+                        idle_seconds=idle_seconds,
+                        timeout_setting=self.idle_timeout_seconds,
+                        trigger_source="server",
+                    )
+                    await self._call_shutdown()
+                    break
+
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            logger.error("[ServerIdleMonitor] Monitor loop error: %s", e, exc_info=True)
+
+    async def _call_shutdown(self):
+        """환경에 따라 적절한 shutdown 호출."""
+        if self._sagemaker:
+            await self._sagemaker_shutdown()
+        else:
+            await self._codebuff_shutdown()
+
+    async def _sagemaker_shutdown(self):
+        """SageMaker delete_app API로 노트북 종료."""
+        try:
+            import boto3
+
+            meta = self._load_sagemaker_metadata()
+            domain_id = meta.get("DomainId") or os.environ.get("DOMAIN_ID", "")
+            space_name = meta.get("SpaceName") or os.environ.get(
+                "SAGEMAKER_SPACE_NAME", ""
+            )
+            app_type = meta.get("AppType", "JupyterLab")
+            app_name = meta.get("AppName", "default")
+
+            if not domain_id or not space_name:
+                logger.error(
+                    "[ServerIdleMonitor] SageMaker shutdown failed: missing DomainId=%s, SpaceName=%s",
+                    domain_id,
+                    space_name,
+                )
+                return
+
+            logger.info(
+                "[ServerIdleMonitor] SageMaker delete_app: domain=%s, space=%s, app_type=%s, app=%s",
+                domain_id,
+                space_name,
+                app_type,
+                app_name,
+            )
+
+            client = boto3.client("sagemaker", region_name="ap-northeast-2")
+            client.delete_app(
+                DomainId=domain_id,
+                SpaceName=space_name,
+                AppType=app_type,
+                AppName=app_name,
+            )
+            logger.info("[ServerIdleMonitor] SageMaker delete_app success")
+        except Exception as e:
+            logger.error("[ServerIdleMonitor] SageMaker shutdown error: %s", e)
+
+    def _load_sagemaker_metadata(self) -> dict:
+        """SageMaker 리소스 메타데이터 로드."""
+        try:
+            with open(SAGEMAKER_METADATA_PATH) as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    async def _codebuff_shutdown(self):
+        """HDSP shutdown API 호출."""
+        import httpx
+
+        if self.hdsp_env == "dev":
+            api_base = "https://hdsp-api-dev.hyundaicard.com"
+        elif self.hdsp_env == "prod":
+            api_base = "https://hdsp-api.hyundaicard.com"
+        else:
+            logger.warning("[ServerIdleMonitor] Unknown HDSP_ENV: %s", self.hdsp_env)
+            return
+
+        api_url = f"{api_base}/k8s/jupyter/{self.project_id}/{self.user_id}"
+        logger.info("[ServerIdleMonitor] Calling shutdown API: DELETE %s", api_url)
+
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.delete(api_url)
+
+            if response.status_code in (200, 204):
+                logger.info("[ServerIdleMonitor] Shutdown API success")
+            else:
+                logger.error(
+                    "[ServerIdleMonitor] Shutdown API failed: %s %s",
+                    response.status_code,
+                    response.text,
+                )
+        except Exception as e:
+            logger.error("[ServerIdleMonitor] Shutdown API error: %s", e)

jupyter_ext/labextension/package.json

@@ -0,0 +1,157 @@
+{
+  "name": "codebuff",
+  "version": "2.1.74",
+  "description": "Codebuff JupyterLab Extension - Thin client for Agent Server",
+  "keywords": [
+    "jupyter",
+    "jupyterlab",
+    "jupyterlab-extension",
+    "ai",
+    "llm",
+    "code-assistant"
+  ],
+  "homepage": "https://github.com/lks21c/codebuff",
+  "bugs": {
+    "url": "https://github.com/lks21c/codebuff/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Your Name",
+    "email": "your.email@example.com"
+  },
+  "files": [
+    "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+    "frontend/styles/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+    "schema/*.json"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "style": "frontend/styles/index.css",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lks21c/codebuff.git"
+  },
+  "scripts": {
+    "build": "jlpm build:lib && jlpm build:labextension:dev",
+    "build:prod": "jlpm clean && jlpm build:lib && jlpm build:labextension",
+    "build:labextension": "jupyter labextension build .",
+    "build:labextension:dev": "jupyter labextension build --development True .",
+    "prebuild:lib": "mkdir -p lib/styles/icons && cp -r frontend/styles/icons/* lib/styles/icons/",
+    "build:lib": "jlpm prebuild:lib && tsc",
+    "clean": "jlpm clean:all",
+    "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+    "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+    "clean:labextension": "rimraf jupyter_ext/labextension",
+    "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+    "eslint": "jlpm eslint:check --fix",
+    "eslint:check": "eslint frontend --cache --ext .ts,.tsx",
+    "install:extension": "jlpm build",
+    "lint": "jlpm lint:check",
+    "lint:check": "jlpm stylelint:check && jlpm eslint:check",
+    "prettier": "jlpm prettier:base --write --list-different",
+    "prettier:base": "prettier \"frontend/**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+    "prettier:check": "jlpm prettier:base --check",
+    "stylelint": "jlpm stylelint:check --fix",
+    "stylelint:check": "stylelint --cache \"frontend/styles/**/*.css\"",
+    "watch": "run-p watch:src watch:labextension",
+    "watch:src": "tsc -w",
+    "watch:labextension": "jupyter labextension watch .",
+    "test:ui": "playwright test",
+    "test:ui:headed": "playwright test --headed",
+    "test:ui:debug": "playwright test --debug",
+    "lint:fix": "jlpm stylelint && jlpm eslint"
+  },
+  "dependencies": {
+    "@codemirror/commands": "6.8.1",
+    "@codemirror/state": "^6.5.2",
+    "@emotion/react": "^11.11.0",
+    "@emotion/styled": "^11.11.0",
+    "@jupyter-widgets/base": "^6.0.0",
+    "@jupyterlab/application": "^4.0.0",
+    "@jupyterlab/cells": "^4.0.0",
+    "@jupyterlab/console": "^4.0.0",
+    "@jupyterlab/launcher": "^4.0.0",
+    "@jupyterlab/notebook": "^4.0.0",
+    "@jupyterlab/rendermime": "^4.0.0",
+    "@jupyterlab/services": "^7.0.0",
+    "@jupyterlab/terminal": "^4.0.0",
+    "@lezer/java": "^1.1.4",
+    "@lezer/javascript": "^1.5.5",
+    "@lezer/python": "^1.1.19",
+    "@lumino/widgets": "^2.0.0",
+    "@mui/icons-material": "^7.3.4",
+    "@mui/material": "^5.14.0",
+    "diff": "^9.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-markdown": "^10.1.0",
+    "react-syntax-highlighter": "^16.1.1",
+    "remark-gfm": "^4.0.1",
+    "sql-formatter": "^15.7.3"
+  },
+  "devDependencies": {
+    "@axe-core/playwright": "^4.8.0",
+    "@codemirror/lang-java": "^6.0.2",
+    "@codemirror/lang-javascript": "^6.2.4",
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/lang-python": "6.2.0",
+    "@jupyterlab/builder": "^4.0.0",
+    "@jupyterlab/galata": "^5.0.0",
+    "@playwright/test": "^1.40.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.45.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-react": "^7.33.0",
+    "eslint-plugin-react-hooks": "^4.6.2",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.0.0",
+    "rimraf": "^5.0.1",
+    "stylelint": "^15.10.0",
+    "stylelint-config-prettier": "^9.0.5",
+    "stylelint-config-recommended": "^13.0.0",
+    "stylelint-config-standard": "^34.0.0",
+    "stylelint-prettier": "^4.0.0",
+    "typescript": "~5.1.6"
+  },
+  "sideEffects": true,
+  "styleModule": "frontend/styles/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "jupyterlab": {
+    "extension": true,
+    "outputDir": "jupyter_ext/labextension",
+    "sharedPackages": {
+      "@jupyterlab/application": {
+        "bundled": false,
+        "singleton": true
+      },
+      "@jupyterlab/cells": {
+        "bundled": false,
+        "singleton": true
+      },
+      "@jupyterlab/notebook": {
+        "bundled": false,
+        "singleton": true
+      },
+      "@jupyterlab/rendermime": {
+        "bundled": false,
+        "singleton": true
+      },
+      "@jupyter-widgets/base": {
+        "bundled": false,
+        "singleton": true
+      }
+    },
+    "_build": {
+      "load": "static/remoteEntry.5292fc9c6df7e7920cc8.js",
+      "extension": "./extension",
+      "style": "./style"
+    }
+  }
+}