codebuff-agent 2.1.74__py3-none-any.whl

jupyter_ext/secrets_bootstrap.py

@@ -0,0 +1,116 @@
+"""AWS Secrets Manager 부트스트랩 — 연결정보를 환경변수로 주입.
+
+HDSP_ENV(dev/prod)에 따라 단일 시크릿에서 vLLM/qdrant/embedding 연결정보를
+읽어 대응 환경변수로 세팅한다. 소싱 코드(llm/service, models/rag,
+vllm_embedding_service)가 env를 config보다 우선 읽으므로, config 파일에
+평문 키를 두지 않아도 된다.
+
+동작:
+- HDSP_ENV 미설정(로컬 등): 아무것도 안 함 → 기존 config 파일 방식.
+- 조회 성공: 시크릿 값들을 대응 env로 주입.
+- 조회 실패: **기동은 정상 진행**하고 CODEBUFF_SECRET_LOAD_ERROR env에 사유만
+  기록 → 구 chat_service 가 이 값을 보고 사용자에게 에러로 노출했다. Chat/Q&A 가
+  codex 로 옮긴 뒤(이슈 #155)에는 Q&A 검색 도구의 실패로만 드러난다.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+# HDSP_ENV → 시크릿 이름 (개발계 WDD / 운영계 WDP)
+_SECRET_NAMES = {"dev": "WDD-BDP-SCM-CODEBUFF", "prod": "WDP-BDP-SCM-CODEBUFF"}
+_REGION = "ap-northeast-2"
+ERROR_ENV = "CODEBUFF_SECRET_LOAD_ERROR"
+
+# 시크릿 JSON 키 → 주입할 환경변수 (없는 키는 스킵 → config 파일 값 사용)
+_KEY_MAP = {
+    "vllm_endpoint": "VLLM_ENDPOINT",
+    "vllm_api_key": "VLLM_API_KEY",
+    "vllm_model": "VLLM_MODEL",
+    "qdrant_mode": "QDRANT_MODE",
+    "qdrant_url": "QDRANT_URL",
+    "qdrant_api_key": "QDRANT_API_KEY",
+    "embedding_endpoint": "EMBEDDING_ENDPOINT",
+    "embedding_api_key": "EMBEDDING_API_KEY",
+    "embedding_model": "EMBEDDING_MODEL",
+    "embedding_dimension": "EMBEDDING_DIMENSION",
+    # codex 서버사이드 접속 (이슈 #88). 없으면 codex 엔진이 드롭다운에서 숨는다.
+    # `codex_api_key` 는 codebuff↔centri 통신 전체의 공유 키다 — 로그 적재(#30)·중앙 설정(#113)도
+    # 이 키 하나로 인증하고, 주소는 아래 클러스터 DNS 로 정한다 (이슈 #113, 2026-09-25).
+    # 커스텀 스킬 동기화(#134)도 같은 키다.
+    "codex_endpoint": "CODEX_SERVER_URL",
+    "codex_api_key": "CODEX_SERVER_API_KEY",
+}
+
+# 개발계·운영계에서 codebuff pod 과 centri 는 같은 hdsp 클러스터에 있어 codex 입구
+# (centri 게이트웨이, centri#1746)의 주소가 클러스터 DNS 로 정해져 있다. 그래서 시크릿에는
+# 키만 두면 된다. 키가 없으면 채우지 않는다 — 채우면 늘 거부되는 엔진이 드롭다운에 뜬다.
+_CENTRI_CLUSTER_HOST = "centri-agent-server.agents.svc.cluster.local:8000"
+_CODEX_CLUSTER_ENDPOINT = f"ws://{_CENTRI_CLUSTER_HOST}/agents/hdsp_rag/codex"
+
+# 공유 키가 있으면 채우는 centri 주소들. 이미 env 에 있으면(로컬 개발 등) 덮지 않는다.
+# 키가 없으면 채우지 않는다 — 채우면 늘 401 을 받는 송신이 뜬다.
+_CENTRI_ENDPOINTS = {
+    "CODEX_SERVER_URL": _CODEX_CLUSTER_ENDPOINT,
+    "CODEBUFF_INGEST_URL": f"http://{_CENTRI_CLUSTER_HOST}/api/v1/codebuff/ingest",
+    "CODEBUFF_CONFIG_URL": f"http://{_CENTRI_CLUSTER_HOST}/api/v1/codebuff/config",
+    "CODEBUFF_SKILLS_URL": f"http://{_CENTRI_CLUSTER_HOST}/api/v1/codebuff/skills",
+}
+
+
+def bootstrap_secrets() -> None:
+    """HDSP_ENV에 맞는 시크릿을 읽어 연결정보 환경변수로 주입.
+
+    서비스/ConfigManager 초기화 전에(확장 로드 시점) 호출해야 한다.
+    """
+    env = os.environ.get("HDSP_ENV", "").strip().lower()
+    secret_name = _SECRET_NAMES.get(env)
+    if not secret_name:
+        # HDSP_ENV 미설정 → SM 미사용 (로컬 등). 이전 에러 있으면 클리어.
+        os.environ.pop(ERROR_ENV, None)
+        return
+
+    try:
+        # bdpengine의 검증된 클라이언트 팩토리 사용 — athena/s3와 동일 경로라
+        # 그 환경의 유효 AWS 자격증명 + 정상 SSL을 그대로 따른다.
+        # (raw boto3 + 기본 자격증명은 환경에 따라 UnrecognizedClientException,
+        #  또는 pyOpenSSL↔cryptography 불일치(GEN_EMAIL)로 실패하므로 bdpengine 우선.
+        #  bdpengine 미설치 환경(로컬 등)에서만 raw boto3로 폴백)
+        try:
+            from bdpengine.functions import get_boto3_client
+
+            client = get_boto3_client("secretsmanager")
+        except ImportError:
+            import boto3
+
+            client = boto3.client("secretsmanager", region_name=_REGION)
+
+        raw = client.get_secret_value(SecretId=secret_name)["SecretString"]
+        data = json.loads(raw)
+
+        injected = []
+        for skey, envk in _KEY_MAP.items():
+            val = data.get(skey)
+            if val is not None and str(val) != "":
+                os.environ[envk] = str(val)
+                injected.append(envk)
+        if os.environ.get("CODEX_SERVER_API_KEY"):
+            for envk, url in _CENTRI_ENDPOINTS.items():
+                if not os.environ.get(envk):
+                    os.environ[envk] = url
+                    injected.append(envk)
+
+        os.environ.pop(ERROR_ENV, None)  # 성공 → 이전 에러 클리어
+        logger.info(
+            "[Secrets] loaded %d connection settings from %s",
+            len(injected),
+            secret_name,
+        )
+    except Exception as e:  # noqa: BLE001 — 기동을 막지 않기 위해 광범위 캐치
+        # 기동은 계속 진행. 채팅 시도 시 노출할 에러만 기록.
+        os.environ[ERROR_ENV] = f"{secret_name}: {type(e).__name__}: {e}"
+        logger.error("[Secrets] failed to load %s: %s", secret_name, e)

jupyter_ext/team_access.py

@@ -0,0 +1,105 @@
+"""Keycloak 팀 클레임으로 기능 접근을 가른다.
+
+codex 엔진은 AI Platform개발실 소속에게만 연다 (이슈 #101). 클레임이 "실 > 팀"
+꼴인지 팀 이름만인지 확인하지 못해서, 판정은 공백·대소문자를 무시한 부분
+일치이고 목록은 `CODEBUFF_CODEX_ALLOWED_TEAMS`(쉼표 구분)로 바꿀 수 있다.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_CODEX_TEAMS = ("AI Platform개발실", "AI플랫폼개발실")
+# 소속과 무관하게 반드시 여는 사번. 환경변수는 여기에 더할 뿐 빼지 못한다.
+_ALWAYS_CODEX_USERS = ("453180",)
+
+
+def _read_claims() -> dict:
+    """`KEYCLOAK_ID_TOKEN` 의 payload. 토큰이 없거나 깨졌으면 빈 dict."""
+    parts = os.environ.get("KEYCLOAK_ID_TOKEN", "").split(".")
+    if len(parts) != 3:
+        return {}
+    try:
+        payload = parts[1] + "=" * (-len(parts[1]) % 4)
+        claims = json.loads(base64.urlsafe_b64decode(payload))
+    except Exception as e:
+        logger.warning(f"Failed to decode Keycloak token: {e}")
+        return {}
+    return claims if isinstance(claims, dict) else {}
+
+
+def read_user_team() -> str:
+    """`KEYCLOAK_ID_TOKEN` 의 팀 클레임. 토큰이 없거나 깨졌으면 빈 문자열."""
+    claim_name = os.environ.get("HDSP_TEAM_CLAIM_NAME", "hcc_team")
+    value = _read_claims().get(claim_name, "")
+    if isinstance(value, list):
+        return " ".join(str(v) for v in value)
+    return str(value or "")
+
+
+def resolve_team() -> str:
+    """로그에 찍을 팀. `HDSP_USER_TEAM` 이 우선이고, 비면 JWT 팀 클레임 (이슈 #98).
+
+    env 주입이 빠진 pod 에서도 성과 지표의 팀 축이 빈 문자열이 되지 않게 한다.
+    **로그에 팀을 찍는 자리**가 이 함수를 쓴다 — `test_team_fallback` 이 그 파일들의
+    직접 읽기를 막는다. 접근 제어(`codex_allowed`)와 PageConfig 는 env 를 따로 읽는다.
+    """
+    # 앞뒤 공백을 뗀다 — centri 는 공백 없는 팀 이름으로 층 행을 저장한다 (이슈 #237)
+    return os.environ.get("HDSP_USER_TEAM", "").strip() or read_user_team().strip()
+
+
+def _norm(text: str) -> str:
+    return "".join(text.split()).lower()
+
+
+def user_ids() -> list:
+    """사번 후보를 이 순서로. 어느 변수로 오는지 확정하지 못해서 셋 다 본다 (이슈 #101).
+
+    커스텀 스킬 동기화(#134)는 첫 값을 centri 에 보내고, 받은 개인 스킬은 후보 중 하나와
+    맞으면 받는다.
+    """
+    raw = [
+        os.environ.get("JUPYTERHUB_USER", ""),
+        os.environ.get("HDSP_BDP_ID", ""),
+        str(_read_claims().get("preferred_username", "") or ""),
+    ]
+    out: list = []
+    for v in raw:
+        v = (v or "").strip()
+        if v and v not in out:
+            out.append(v)
+    return out
+
+
+def _user_ids() -> set:
+    return set(user_ids())
+
+
+def _codex_user_allowed() -> bool:
+    extra = os.environ.get("CODEBUFF_CODEX_ALLOWED_USERS", "").split(",")
+    allowed = {u.strip() for u in (*_ALWAYS_CODEX_USERS, *extra) if u.strip()}
+    return bool(_user_ids() & allowed)
+
+
+def codex_allowed() -> bool:
+    """팀 클레임이 허용 목록 중 하나를 포함하면 True.
+
+    토큰 자체가 없으면 개발 환경으로 보고 True. 토큰은 있는데 깨졌거나 팀
+    클레임이 비었으면 False — 그 경우까지 열면 403 이 우회된다.
+    허용 사번(`_ALWAYS_CODEX_USERS` + `CODEBUFF_CODEX_ALLOWED_USERS`)은 팀과 무관하게 True.
+    """
+    if _codex_user_allowed():
+        return True
+    if not os.environ.get("KEYCLOAK_ID_TOKEN", ""):
+        return True
+    team = read_user_team()
+    if not team:
+        return False
+    raw = os.environ.get("CODEBUFF_CODEX_ALLOWED_TEAMS", "")
+    allowed = [t for t in raw.split(",") if t.strip()] or list(_DEFAULT_CODEX_TEAMS)
+    return any(_norm(t) in _norm(team) for t in allowed)

jupyter_ext/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for jupyter_ext package."""

jupyter_ext/tests/test_context.py

@@ -0,0 +1,234 @@
+"""Tests for NotebookContextManager."""
+
+import pytest
+
+from jupyter_ext.tools.context import (
+    CellInfo,
+    NotebookContext,
+    NotebookContextManager,
+)
+
+
+class TestCellInfo:
+    """Tests for CellInfo dataclass."""
+
+    def test_cell_info_creation(self):
+        """Test CellInfo creation with default values."""
+        cell = CellInfo(index=0, cell_type="code", source="print('hello')")
+        assert cell.index == 0
+        assert cell.cell_type == "code"
+        assert cell.source == "print('hello')"
+        assert cell.outputs == []
+        assert cell.execution_count is None
+
+    def test_cell_info_with_outputs(self):
+        """Test CellInfo with outputs."""
+        outputs = [{"output_type": "stream", "text": "hello\n"}]
+        cell = CellInfo(
+            index=1,
+            cell_type="code",
+            source="print('hello')",
+            outputs=outputs,
+            execution_count=5,
+        )
+        assert cell.outputs == outputs
+        assert cell.execution_count == 5
+
+
+class TestNotebookContext:
+    """Tests for NotebookContext dataclass."""
+
+    def test_empty_notebook(self):
+        """Test empty notebook context."""
+        ctx = NotebookContext(path="test.ipynb")
+        assert ctx.path == "test.ipynb"
+        assert ctx.cell_count == 0
+        assert ctx.get_code_cells() == []
+        assert ctx.get_markdown_cells() == []
+
+    def test_notebook_with_cells(self):
+        """Test notebook with mixed cells."""
+        cells = [
+            CellInfo(index=0, cell_type="code", source="x = 1"),
+            CellInfo(index=1, cell_type="markdown", source="# Header"),
+            CellInfo(index=2, cell_type="code", source="print(x)"),
+        ]
+        ctx = NotebookContext(path="test.ipynb", cells=cells)
+
+        assert ctx.cell_count == 3
+        assert len(ctx.get_code_cells()) == 2
+        assert len(ctx.get_markdown_cells()) == 1
+
+    def test_get_cell(self):
+        """Test getting a cell by index."""
+        cells = [
+            CellInfo(index=0, cell_type="code", source="x = 1"),
+            CellInfo(index=1, cell_type="markdown", source="# Header"),
+        ]
+        ctx = NotebookContext(path="test.ipynb", cells=cells)
+
+        assert ctx.get_cell(0) is not None
+        assert ctx.get_cell(0).source == "x = 1"
+        assert ctx.get_cell(1).cell_type == "markdown"
+        assert ctx.get_cell(2) is None
+        assert ctx.get_cell(-1) is None
+
+
+class TestNotebookContextManager:
+    """Tests for NotebookContextManager."""
+
+    @pytest.fixture
+    def context_manager(self):
+        """Create a NotebookContextManager instance."""
+        return NotebookContextManager()
+
+    @pytest.fixture
+    def sample_notebook_model(self):
+        """Create a sample notebook model."""
+        return {
+            "content": {
+                "cells": [
+                    {
+                        "cell_type": "code",
+                        "source": "import pandas as pd",
+                        "outputs": [],
+                        "execution_count": 1,
+                        "metadata": {},
+                    },
+                    {
+                        "cell_type": "markdown",
+                        "source": "# Data Analysis",
+                        "metadata": {},
+                    },
+                    {
+                        "cell_type": "code",
+                        "source": "df = pd.read_csv('data.csv')",
+                        "outputs": [],
+                        "execution_count": 2,
+                        "metadata": {},
+                    },
+                ],
+                "metadata": {
+                    "kernelspec": {
+                        "name": "python3",
+                        "display_name": "Python 3",
+                    }
+                },
+            }
+        }
+
+    def test_initial_state(self, context_manager):
+        """Test initial state of context manager."""
+        assert context_manager.current_notebook is None
+        assert context_manager.notebook_model is None
+
+    def test_set_notebook(self, context_manager, sample_notebook_model):
+        """Test setting notebook context."""
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+
+        assert context_manager.current_notebook is not None
+        assert context_manager.current_notebook.path == "test.ipynb"
+        assert context_manager.current_notebook.cell_count == 3
+        assert context_manager.current_notebook.kernel_name == "python3"
+
+    def test_get_summary(self, context_manager, sample_notebook_model):
+        """Test getting notebook summary."""
+        # Without notebook
+        summary = context_manager.get_summary()
+        assert summary == {"status": "no_notebook"}
+
+        # With notebook
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+        summary = context_manager.get_summary()
+
+        assert summary["path"] == "test.ipynb"
+        assert summary["cell_count"] == 3
+        assert summary["code_cells"] == 2
+        assert summary["markdown_cells"] == 1
+        assert summary["kernel"] == "python3"
+
+    def test_update_cell(self, context_manager, sample_notebook_model):
+        """Test updating a cell."""
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+
+        # Update existing cell
+        assert context_manager.update_cell(0, "import numpy as np")
+
+        # Verify in notebook model
+        cells = context_manager.notebook_model["content"]["cells"]
+        assert cells[0]["source"] == "import numpy as np"
+
+        # Verify in context
+        assert context_manager.current_notebook.cells[0].source == "import numpy as np"
+
+        # Invalid index
+        assert not context_manager.update_cell(10, "x = 1")
+        assert not context_manager.update_cell(-1, "x = 1")
+
+    def test_insert_cell(self, context_manager, sample_notebook_model):
+        """Test inserting a new cell."""
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+
+        # Insert after index 0
+        new_index = context_manager.insert_cell(
+            source="# New cell",
+            cell_type="code",
+            insert_after=0,
+        )
+
+        assert new_index == 1
+        assert context_manager.current_notebook.cell_count == 4
+
+        # Append to end
+        new_index = context_manager.insert_cell(
+            source="print('done')",
+            cell_type="code",
+        )
+
+        assert new_index == 4
+        assert context_manager.current_notebook.cell_count == 5
+
+    def test_insert_markdown_cell(self, context_manager, sample_notebook_model):
+        """Test inserting a markdown cell."""
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+
+        new_index = context_manager.insert_cell(
+            source="## Section",
+            cell_type="markdown",
+            insert_after=1,
+        )
+
+        cells = context_manager.notebook_model["content"]["cells"]
+        assert cells[new_index]["cell_type"] == "markdown"
+        assert cells[new_index]["source"] == "## Section"
+
+    def test_delete_cell(self, context_manager, sample_notebook_model):
+        """Test deleting a cell."""
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+        initial_count = context_manager.current_notebook.cell_count
+
+        # Delete middle cell
+        assert context_manager.delete_cell(1)
+        assert context_manager.current_notebook.cell_count == initial_count - 1
+
+        # Check remaining cells have correct indices
+        for i, cell in enumerate(context_manager.current_notebook.cells):
+            assert cell.index == i
+
+        # Invalid index
+        assert not context_manager.delete_cell(10)
+
+    def test_clear(self, context_manager, sample_notebook_model):
+        """Test clearing notebook context."""
+        context_manager.set_notebook("test.ipynb", sample_notebook_model)
+        assert context_manager.current_notebook is not None
+
+        context_manager.clear()
+
+        assert context_manager.current_notebook is None
+        assert context_manager.notebook_model is None
+
+    def test_insert_without_notebook_raises(self, context_manager):
+        """Test that insert raises when no notebook is set."""
+        with pytest.raises(ValueError, match="No notebook model set"):
+            context_manager.insert_cell(source="x = 1")