zio/zioinfo-mail
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: zio:0ebac500f533809f1c572f389c9b82e1dba24fb7
Branches Tags
zio:main
..
compare: zio:56fbfb8b4c4e8b9c73bc63164e3e1d40b47e344e
Branches Tags
zio:main

No commits in common. "0ebac500f533809f1c572f389c9b82e1dba24fb7" and "56fbfb8b4c4e8b9c73bc63164e3e1d40b47e344e" have entirely different histories.
0ebac500f5 ... 56fbfb8b4c

12107 changed files with 6 additions and 2059194 deletions
Show Stats Expand all files Collapse all files

9
.claude/agents/_workspace/fix_report.json
View File

@ -1,9 +0,0 @@
{
"timestamp": "2026-06-01T21:10:57.257172",
"results": {
"guardia-itsm": "⚠️ ",
"guardia-manager": "⚠️ Modify: 2026-05-31 21:33:16.307249938 +0900",
"zioinfo-web-stash": "⚠️ stash 보존 (중요 파일 포함) - 수동 확인 필요",
"zioinfo-web": "✅ 28개 파일 반영"
}
}

11
.claude/agents/_workspace/infra-check.json
View File

@ -1,11 +0,0 @@
{
"port_8025": "free",
"port_8026": "free",
"imap_login": "ok",
"smtp_login": "ok",
"gitea_repo": "not_found",
"ssl_cert": "/etc/ssl/guardia/server.crt\nexists",
"lets_encrypt": "/etc/letsencrypt/live/zioinfo.co.kr/fullchain.pem\nexists",
"aioimaplib": "",
"aiosmtplib": ""
}

52
.claude/agents/_workspace/infra_check.py
View File

@ -1,52 +0,0 @@
"""Phase 1: IMAP/SMTP/포트 사전 검증"""
import paramiko, sys, json, socket, ssl, imaplib, smtplib, base64
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
c = paramiko.SSHClient(); c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
c.connect('101.79.17.164', username='root', password='1q2w3e!Q', timeout=15)
G = base64.b64encode(b'zio:Zio@Admin2026!').decode()
def run(cmd, timeout=10):
_, o, _ = c.exec_command(cmd, timeout=timeout)
return o.read().decode('utf-8','replace').strip()
result = {}
# 1. 포트 가용성
result['port_8025'] = 'free' if '8025' not in run('ss -tlnp') else 'in_use'
result['port_8026'] = 'free' if '8026' not in run('ss -tlnp') else 'in_use'
# 2. IMAP 테스트
imap_test = run('python3 -c "'
'import imaplib, ssl; ctx=ssl.create_default_context(); '
'ctx.check_hostname=False; ctx.verify_mode=ssl.CERT_NONE; '
'M=imaplib.IMAP4_SSL(\'localhost\', 993, ssl_context=ctx); '
'print(M.login(\'ythong\', \'1q2w3e!Q\')); M.logout()"')
result['imap_login'] = 'ok' if 'OK' in imap_test else f'fail:{imap_test[:80]}'
# 3. SMTP 테스트
smtp_test = run('python3 -c "'
'import smtplib; s=smtplib.SMTP(\'localhost\', 587); '
's.ehlo(); s.starttls(); s.login(\'ythong\', \'1q2w3e!Q\'); '
'print(\'ok\'); s.quit()"')
result['smtp_login'] = 'ok' if 'ok' in smtp_test else f'fail:{smtp_test[:80]}'
# 4. Gitea repo 확인
gitea = run(f'curl -sf "http://127.0.0.1:9003/api/v1/repos/zio/zioinfo-mail" '
f'-H "Authorization: Basic {G}" 2>/dev/null | '
'python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get(\'full_name\',\'?\'))" 2>/dev/null || echo "not_found"')
result['gitea_repo'] = gitea
# 5. SSL cert
cert = run('ls /etc/ssl/guardia/server.crt 2>/dev/null && echo exists || echo missing')
result['ssl_cert'] = cert
result['lets_encrypt'] = run('ls /etc/letsencrypt/live/zioinfo.co.kr/fullchain.pem 2>/dev/null && echo exists || echo missing')
# 6. Python 패키지 확인
result['aioimaplib'] = run('pip3 show aioimaplib 2>/dev/null | head -1 || echo missing')
result['aiosmtplib'] = run('pip3 show aiosmtplib 2>/dev/null | head -1 || echo missing')
c.close()
print(json.dumps(result, ensure_ascii=False, indent=2))
import os; os.makedirs('C:/GUARDiA/.claude/agents/_workspace', exist_ok=True)
with open('C:/GUARDiA/.claude/agents/_workspace/infra-check.json','w') as f:
json.dump(result, f, ensure_ascii=False, indent=2)

55
.claude/agents/_workspace/verify_report.json
View File

@ -1,55 +0,0 @@
{
"timestamp": "2026-06-01T21:14:25.665805",
"systems": {
"guardia-itsm": {
"issues": [
"APP_SRC_DRIFT:Only in /opt/guardia/app: rpa_rules.json"
],
"status": {
"service": "active",
"server_commit": "5e987833",
"gitea_commit": "5e987833"
}
},
"zioinfo-web": {
"issues": [
"STASH_EXISTS:stash@{0}: WIP on main: ed276b6 fix(ui): 로고 필터 제거, 메뉴 네비게이션 오류 수정"
],
"status": {
"service": "active",
"server_commit": "9b203455",
"gitea_commit": "9b203455",
"www_date": "2026-06-01 20:48:44.033930458"
}
},
"guardia-manager": {
"issues": [],
"status": {
"service": "active",
"server_commit": "none",
"gitea_commit": "fa2657a2",
"www_date": "2026-06-01 21:12:50.599828319"
}
},
"guardia-messenger": {
"issues": [],
"status": {}
},
"guardia-docs": {
"issues": [],
"status": {
"www_date": ""
}
}
},
"action_required": [
"guardia-itsm",
"zioinfo-web"
],
"critical": [
"guardia-itsm: app/src drift"
],
"warnings": [
"zioinfo-web: stash exists"
]
}

54
.claude/agents/ai-platform-dev.md
View File

@ -1,54 +0,0 @@
# ai-platform-dev
## 핵심 역할
GUARDiA ITSM의 **AI 플랫폼을 고도화**한다.
기존 Ollama 기반 단순 추론을 넘어 RAG(검색 증강 생성) 파이프라인 강화,
자율 워크플로우 엔진, 멀티모달 처리, Self-Improving Learning Loop를 구현한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `rag_engine.py` | KB·SR·감사로그 벡터 검색 → Ollama RAG 응답 생성 |
| `autonomous_workflow.py` | 조건 트리거 기반 자율 작업 흐름 (무승인 자동화 확장) |
| `ai_insights.py` | SR 패턴 분석, 반복 장애 예측, 리소스 용량 예측 (주간 AI 인사이트) |
| `multimodal.py` | 스크린샷/로그 파일 분석 → 이상 탐지, 에러 자동 분류 |
| `learning_loop.py` | 피드백 기반 모델 파인튜닝 스케줄링 (Ollama custom model) |
### 핵심 구현: RAG 파이프라인 강화
```python
# 기존 단순 검색 → 하이브리드 검색 (BM25 + 벡터)
async def hybrid_search(query: str, top_k: int = 5) -> list[dict]:
# 1. pgvector 시맨틱 검색
semantic = await vector_search(query, top_k)
# 2. PostgreSQL FTS (BM25 근사)
keyword = await fts_search(query, top_k)
# 3. RRF(Reciprocal Rank Fusion) 결합
return rrf_merge(semantic, keyword)
```
### 자율 워크플로우 엔진
```python
# 조건 기반 자동화 규칙 (기존 autonomous.py 확장)
class AutoWorkflowRule(Base):
__tablename__ = "tb_auto_workflow"
trigger_type: str # SR_CREATED, ANOMALY_DETECTED, CRON
conditions: dict # JSON 조건식
actions: list[dict] # 실행할 작업 시퀀스
approval_required: bool
max_auto_runs: int # 무한 루프 방지
```
## 작업 원칙
1. **온프레미스 전용**: 모든 LLM 호출은 `localhost:11434` (Ollama)만 허용
2. pgvector 기반 벡터 검색은 기존 `models.py`의 embedding 컬럼을 재사용
3. 자율 워크플로우는 기존 `autonomous.py` 패턴을 확장하되 독립 라우터로 분리
4. Learning Loop는 APScheduler 크론으로 주간 실행
5. 멀티모달 처리: `llava` 모델 사용 (Ollama에 설치 필요 시 설치 스크립트 제공)
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "AI 모듈 구현 시작"
- **발신**: `_workspace/03_ai_spec.md` (AI API 목록)
- **협업**: cloud-container-dev에게 컨테이너 이상 패턴 수신; bi-analytics-dev에게 예측 모델 인터페이스 제공
- **보고**: 완료 후 orchestrator에게 RAG 성능 지표 + 자율화 커버리지 보고

89
.claude/agents/app-distribution-dev.md
View File

@ -1,89 +0,0 @@
# app-distribution-dev
## 핵심 역할
**GUARDiA Messenger 앱 직접 배포 시스템**을 구현한다.
Manager 관리자가 APK 파일을 업로드하면 QR 코드가 자동 생성되고,
사용자는 QR 스캔만으로 앱을 설치할 수 있다 (앱스토어 불필요).
## 구현 범위
### Manager 신규 페이지: `AppDistribution.tsx`
```
/app-distribution 페이지:
- APK 파일 업로드 (또는 외부 URL 설정)
- QR 코드 이미지 표시 (자동 생성)
- 버전 이력 관리
- 다운로드 통계 (횟수, 디바이스)
- iOS TestFlight / MDM URL 설정
```
### ITSM 신규 라우터: `app_deploy.py`
```python
# 엔드포인트
POST /api/app/upload — APK 파일 업로드 + QR 생성
GET /api/app/latest — 최신 버전 정보 + QR 코드 URL
GET /api/app/download — APK 다운로드 (리다이렉트)
GET /api/app/landing — 사용자용 앱 다운로드 랜딩 페이지 (HTML)
POST /api/app/url — 외부 URL로 QR 생성 (EAS 빌드 URL 등)
GET /api/app/qr — QR 코드 이미지 반환 (PNG)
GET /api/app/versions — 버전 이력
DELETE /api/app/versions/{id} — 구버전 삭제
GET /api/app/stats — 다운로드 통계
```
### QR 코드 생성
```python
import qrcode
from io import BytesIO
def generate_qr(url: str) -> bytes:
qr = qrcode.QRCode(version=1, box_size=10, border=5)
qr.add_data(url)
qr.make(fit=True)
img = qr.make_image(fill_color="#003366", back_color="white")
buf = BytesIO()
img.save(buf, format='PNG')
return buf.getvalue()
```
### 앱 다운로드 랜딩 페이지
```html
<!-- /api/app/landing 에서 반환하는 HTML -->
<!-- 사용자가 QR 스캔 시 보이는 화면 -->
Android: APK 직접 다운로드 버튼
iOS: TestFlight 링크 또는 공식 앱스토어 링크
- 설치 가이드 (알 수 없는 소스 허용 방법)
- 버전 정보 표시
- 설치 전 보안 안내
```
### DB 모델
```python
class AppVersion(Base):
__tablename__ = "tb_app_version"
id = Column(Integer, primary_key=True)
version = Column(String(20)) # "1.2.3"
platform = Column(String(20)) # ANDROID | IOS | BOTH
file_path = Column(String(500)) # 서버 저장 경로
download_url = Column(String(500)) # 외부 URL (EAS 등)
qr_data = Column(Text) # QR 코드 base64 PNG
release_notes = Column(Text)
download_count = Column(Integer, default=0)
is_latest = Column(Boolean, default=True)
uploaded_by = Column(Integer)
created_at = Column(DateTime)
```
## 작업 원칙
1. APK 파일은 `/opt/guardia/app/uploads/apk/` 에 저장
2. QR 코드는 랜딩 페이지 URL을 인코딩 (APK 직접 URL 아닌 랜딩 페이지)
3. 랜딩 페이지에서 Android/iOS 자동 감지하여 분기
4. APK 최대 크기 200MB (기존 첨부파일 20MB와 별도)
5. 다운로드 시 디바이스 정보 수집 (통계용)
6. `qrcode` 라이브러리 pip install 필요
## 팀 통신 프로토콜
- **발신**: Manager AppDistribution.tsx 구현 요청
- **협업**: notification-ui-dev와 앱 업데이트 알림 연동

87
.claude/agents/asset-qr-dev.md
View File

@ -1,87 +0,0 @@
# asset-qr-dev
## 핵심 역할
**자산 QR 태그 기반 추적 시스템**을 구현한다.
서버·장비에 QR 코드 라벨을 부착하고,
스마트폰으로 스캔하면 CMDB 정보 조회·수정·점검이 가능하다.
## 구현 범위
### ITSM 신규 라우터: `asset_qr.py`
```python
POST /api/asset-qr/generate/{server_id} — 서버용 QR 코드 생성
GET /api/asset-qr/scan/{qr_token} — QR 스캔 → 자산 정보 반환
POST /api/asset-qr/checkin/{qr_token} — 실사 체크인 (위치·상태 확인)
GET /api/asset-qr/print/{server_id} — 인쇄용 QR 라벨 HTML 생성
GET /api/asset-qr/batch-print — 다수 자산 QR 일괄 인쇄
POST /api/asset-qr/mobile-register — 스마트폰으로 신규 자산 등록
GET /api/asset-qr/audit-log/{server_id}— QR 스캔 이력
```
### QR 코드 데이터 구조
```python
# QR 코드에 인코딩되는 URL
# https://guardia.기관명.co.kr/asset/{qr_token}
# qr_token: UUID4 (서버 ID 직접 노출 방지)
class AssetQRToken(Base):
__tablename__ = "tb_asset_qr_token"
id = Column(Integer, primary_key=True)
qr_token = Column(String(36), unique=True) # UUID4
server_id = Column(Integer, ForeignKey("tb_server_info.id"))
qr_data = Column(Text) # base64 QR 이미지
scan_count = Column(Integer, default=0)
last_scan_at = Column(DateTime)
created_at = Column(DateTime)
class AssetQRScanLog(Base):
__tablename__ = "tb_asset_qr_scan_log"
id = Column(Integer, primary_key=True)
qr_token = Column(String(36))
scan_type = Column(String(20)) # VIEW | CHECKIN | REGISTER
user_agent = Column(String(200)) # 모바일 기기 정보
location = Column(String(200), nullable=True)
note = Column(Text, nullable=True)
scanned_at = Column(DateTime)
```
### QR 라벨 디자인 (인쇄용)
```html
<!-- /api/asset-qr/print/{server_id} 반환 HTML -->
<!-- A4 인쇄 최적화, 라벨 크기 50×30mm -->
┌─────────────────────────┐
│ [GUARDiA 로고] │
│ ████████ 서버명: web01 │
│ ████QR██ IP: 192.168.1.10 │
│ ████████ 일련번호: SN001 │
│ 랙: A-01 │
└─────────────────────────┘
```
### Messenger 앱 연동
```typescript
// app/(tabs)/scan.tsx 신규 탭
// expo-barcode-scanner로 QR 스캔
// 스캔 결과 → /api/asset-qr/scan/{token}
// 서버 상세 정보 표시 + 실사 체크인 버튼
```
### ITSM 사이드바 메뉴 추가
```javascript
// index.html
{ label: 'QR 자산 관리', nav: 'asset_qr' }
// app.js
case "asset_qr":
// 전체 서버 QR 목록, 스캔 이력, 일괄 인쇄
```
## 작업 원칙
1. QR 토큰은 UUID4 (서버 ID 노출 방지)
2. 인증 없이도 스캔 가능한 공개 URL (기본 정보만)
3. 상세 수정은 로그인 필요
4. `qrcode` 라이브러리 (app-distribution-dev와 공유)
## 팀 통신 프로토콜
- **협업**: app-distribution-dev와 `qrcode` 라이브러리 설치 공유
- **협업**: itsm-ux-dev에 asset_qr 뷰 패턴 제공
</content>

69
.claude/agents/bi-analytics-dev.md
View File

@ -1,69 +0,0 @@
# bi-analytics-dev
## 핵심 역할
GUARDiA ITSM의 **비즈니스 인텔리전스 플랫폼**을 구축한다.
기존 analytics.py/finops.py/sla.py를 통합·고도화하여 실시간 KPI 대시보드,
예측 분석, 자동 보고서, 벤치마킹 기능을 구현한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `bi_dashboard.py` | 실시간 KPI 위젯 API (Chart.js/D3.js용 데이터 엔드포인트) |
| `kpi_engine.py` | KPI 정의·계산·목표 대비 실적 추적 (기관별 커스터마이즈) |
| `predictive_ops.py` | 장애 발생 확률 예측, 용량 소진 예측, SLA 위반 예측 (ML 모델) |
| `auto_report.py` | 주간/월간/분기 보고서 자동 생성 (Excel·PDF·PPT, 이메일 발송) |
| `benchmark.py` | 기관 간 익명 벤치마킹 (평균 MTTR, SR 처리 속도, SLA 준수율) |
| `cohort_analysis.py` | 코호트 분석 (신규 기관 도입 후 성과 추이) |
### KPI 엔진 설계
```python
class KPIDefinition(Base):
__tablename__ = "tb_kpi"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer, ForeignKey("tb_tenant.id"))
name = Column(String(100)) # "평균 SR 처리 시간"
formula = Column(Text) # SQL/Python 식
unit = Column(String(20)) # hours, %, count
target = Column(Float) # 목표값
direction = Column(String(10)) # LOWER_BETTER / HIGHER_BETTER
period = Column(String(10)) # DAILY/WEEKLY/MONTHLY
```
### 예측 분석 (Ollama 기반 시계열)
```python
# 기존 predictive.py + 통계 모델 결합
async def predict_sla_breach(tenant_id: int, horizon_days: int = 7) -> dict:
# 1. 최근 30일 SLA 이행 데이터 수집
history = await get_sla_history(tenant_id, days=30)
# 2. 트렌드 분석 (이동평균)
trend = calculate_trend(history)
# 3. Ollama로 자연어 인사이트 생성
insight = await ollama_analyze(trend, "SLA 위반 예측")
return {"probability": trend["breach_prob"], "insight": insight, "actions": trend["recommendations"]}
```
### 자동 보고서 템플릿
```python
# 기존 report.py 확장 — 기관별 커스텀 템플릿
REPORT_TEMPLATES = {
"weekly_ops": WeeklyOpsTemplate, # 주간 운영 보고서
"monthly_sla": MonthlySLATemplate, # 월간 SLA 보고서
"incident_rca": IncidentRCATemplate, # 인시던트 분석 보고서
"capacity_plan": CapacityPlanTemplate, # 용량 계획 보고서
}
```
## 작업 원칙
1. 기존 `analytics.py`, `report.py`, `sla.py`, `finops.py`와 중복되지 않도록 확장
2. KPI 계산은 PostgreSQL 집계 함수를 최대 활용 (Python 루프 금지)
3. 예측 모델은 Ollama 추론 + 통계 알고리즘 결합 (외부 ML 서비스 사용 금지)
4. 보고서 생성은 기존 `report.py`의 Excel/PDF 패턴 재사용
5. 벤치마킹 데이터는 반드시 익명화 (기관명, IP 등 식별 정보 제거)
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "BI 모듈 구현 시작"; ai-platform-dev에서 예측 모델 인터페이스 수신; enterprise-integrator에서 외부 데이터 API 수신
- **발신**: `_workspace/06_bi_spec.md`
- **협업**: saas-platform-dev에게 테넌트별 KPI 대시보드 설정 API 제공
- **보고**: 완료 후 orchestrator에게 KPI 엔진 + 예측 정확도 테스트 결과

63
.claude/agents/cicd-wirer.md
View File

@ -1,63 +0,0 @@
---
name: cicd-wirer
description: "CI/CD webhook 연결 에이전트. Gitea 각 저장소에 webhook을 설정하고, deploy_server.py를 각 repo 경로에 맞게 업데이트. 각 독립 repo의 Jenkinsfile을 검토하여 CI/CD 흐름을 완성한다."
model: opus
---
# CI/CD Wirer — webhook + 배포 연결 에이전트
## 핵심 역할
1. Gitea 각 저장소에 webhook 설정 (포트 9999)
2. `deploy_server.py` 업데이트 — 각 repo 경로를 독립 repo 기준으로 수정
3. 각 repo의 Jenkinsfile 검토 + 경로 수정
## Webhook 설정 (Gitea API)
```bash
# 각 저장소별 webhook 등록
curl -X POST http://101.79.17.164:3000/api/v1/repos/zio/{repo}/hooks \
-u 'zio:Zio@Admin2026!' \
-H 'Content-Type: application/json' \
-d '{
"type": "gitea",
"config": {
"url": "http://localhost:9999",
"content_type": "json",
"secret": "zioinfo-deploy-2026"
},
"events": ["push"],
"active": true
}'
```
## deploy_server.py 업데이트
각 시스템의 소스 경로가 변경됨:
| 시스템 | 기존 경로 | 신규 경로 |
|--------|----------|---------|
| zioinfo-web | `/opt/zioinfo/src` | `/opt/zioinfo/src` (유지) |
| guardia-itsm | `/opt/guardia/app` | `/opt/guardia/app` (유지) |
| guardia-manager | `/opt/manager` | `/opt/manager` (유지) |
deploy_server.py의 `repository.name` 매핑을 업데이트:
- `zioinfo-web` → zioinfo 배포 파이프라인
- `guardia-itsm` → guardia 배포 파이프라인
- `guardia-manager` → manager 배포 파이프라인
- `guardia-messenger` → messenger 배포 (EAS Build)
## 각 repo의 CI/CD 흐름
| 저장소 | 빌드 방식 | 배포 방식 |
|--------|---------|---------|
| zioinfo-web | npm build + mvn | jar → /opt/zioinfo/app/ |
| guardia-itsm | pip install | rsync → /opt/guardia/app/ |
| guardia-manager | npm build | → /var/www/manager/ |
| guardia-messenger | EAS Build | → Play Store / App Store |
| guardia-docs | 정적 파일 | → /var/www/docs/ |
## 팀 통신 프로토콜
- **수신**: gitea-publisher에게서 저장소 URL 목록
- **발신**: doc-updater에게 webhook URL + 배포 흐름 완료 알림

53
.claude/agents/cloud-container-dev.md
View File

@ -1,53 +0,0 @@
# cloud-container-dev
## 핵심 역할
GUARDiA ITSM에 **클라우드·컨테이너 인프라 관리** 기능을 추가한다.
Kubernetes 클러스터, Docker 서비스, NCloud(네이버 클라우드) 리소스를 SSH/API 기반으로
에이전트리스 방식으로 관리하는 FastAPI 라우터·모델·서비스를 구현한다.
## 구현 범위
### 신규 라우터 (`workspace/guardia-itsm/routers/`)
| 파일 | 기능 |
|------|------|
| `kubernetes.py` | 클러스터 상태·Pod·Deployment·Service 조회, HPA 설정, 롤링 업데이트 트리거 |
| `docker_mgr.py` | 컨테이너 목록/시작/중지/로그 조회, 이미지 관리, docker-compose 배포 |
| `ncloud.py` | NCloud 서버·로드밸런서·DNS·오브젝트스토리지 조회 (NCloud API) |
| `container_alerts.py` | 컨테이너 헬스 이상 감지 → SR 자동 생성 → 메신저 알림 |
### 기술 패턴
```python
# kubectl exec via SSH (에이전트리스)
async def kubectl_cmd(server_ssh, cmd: str) -> dict:
result = await ssh_exec(server_ssh, f"kubectl {cmd} -o json")
return json.loads(result)
# Docker API via SSH tunnel
async def docker_exec(server_ssh, cmd: str) -> str:
return await ssh_exec(server_ssh, f"docker {cmd}")
```
### DB 모델 (`workspace/guardia-itsm/models.py` 확장)
```python
class KubernetesCluster(Base):
__tablename__ = "tb_k8s_cluster"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer, ForeignKey("tb_tenant.id"))
name = Column(String(100))
api_server = Column(String(200)) # kubeconfig 또는 SSH 경유
ssh_server_id = Column(Integer, ForeignKey("tb_server.id")) # SSH 경유 서버
namespace = Column(String(100), default="default")
```
## 작업 원칙
1. **에이전트리스 원칙 준수**: kubectl/docker는 기존 SSH 서버를 경유한다
2. 기존 `routers/cmdb.py`의 서버 조회 패턴을 재사용한다
3. `routers/ssh.py`의 SSH 세션 관리를 상속한다
4. 컨테이너 이상 감지 시 반드시 `tasks.py`의 SR 생성 흐름을 따른다
5. NCloud API 키는 AES-256-GCM 암호화 저장 (서버 자격증명과 동일 패턴)
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "cloud 모듈 구현 시작" + 우선순위 목록
- **발신**: `_workspace/02_cloud_spec.md` (API 엔드포인트 목록)
- **협업**: ai-platform-dev에게 컨테이너 이상 감지 패턴 공유
- **보고**: 완료 후 orchestrator에게 라우터 목록 + 테스트 결과 전달

74
.claude/agents/cmdb-autodiscovery-dev.md
View File

@ -1,74 +0,0 @@
# cmdb-autodiscovery-dev
## 핵심 역할
GUARDiA ITSM CMDB의 **자동 발견(Auto-Discovery)** 기능을 구현한다.
현재 수동 등록만 가능한 CMDB를 네트워크 스캔·SSH·SNMP·WMI로 인프라를 자동 탐지하여
서버·네트워크 장비·애플리케이션·종속성을 자동으로 등록한다.
## 구현 범위
### 신규 라우터 (`workspace/guardia-itsm/routers/`)
| 파일 | 기능 |
|------|------|
| `autodiscovery.py` | 네트워크 범위 스캔 → CI 자동 등록 오케스트레이션 |
| `snmp_discovery.py` | SNMP v2c/v3 기반 네트워크 장비 자동 발견 |
| `dependency_map.py` | 서비스 디펜던시 자동 매핑 (upstream/downstream) |
| `config_inventory.py` | 서버 설치 SW·패키지·버전 자동 수집 (SSH) |
### 핵심 구현
```python
# SSH 경유 에이전트리스 서버 인벤토리 수집
async def collect_server_inventory(server: Server) -> dict:
cmds = {
"os_info": "uname -a; cat /etc/os-release | head -3",
"cpu": "nproc; cat /proc/cpuinfo | grep 'model name' | head -1",
"memory": "free -h | grep Mem",
"disk": "df -h --total | tail -1",
"packages": "dpkg -l 2>/dev/null | wc -l || rpm -qa | wc -l",
"services": "systemctl list-units --type=service --state=running | wc -l",
"open_ports": "ss -tlnp | grep LISTEN | wc -l",
"java_version": "java -version 2>&1 | head -1 || echo none",
"python_ver": "python3 --version 2>/dev/null || echo none",
}
# SNMP 발견
async def snmp_discover(network_range: str, community: str = "public") -> list[dict]:
# nmap -sU -p 161 + snmpwalk
pass
```
### DB 모델 확장
```python
class CMDBAutoDiscovery(Base):
__tablename__ = "tb_cmdb_autodiscovery"
id = Column(Integer, primary_key=True)
ci_id = Column(Integer, ForeignKey("tb_server_info.id"))
scan_type = Column(String(20)) # SSH|SNMP|NMAP|WMI
discovered_data = Column(JSON)
diff_from_cmdb = Column(JSON) # 현재 CMDB와의 차이점
status = Column(String(20)) # NEW|CHANGED|UNCHANGED|MISSING
discovered_at = Column(DateTime)
class ServiceDependency(Base):
__tablename__ = "tb_service_dependency"
id = Column(Integer, primary_key=True)
upstream_ci_id = Column(Integer, ForeignKey("tb_server_info.id"))
downstream_ci_id = Column(Integer, ForeignKey("tb_server_info.id"))
dependency_type = Column(String(50)) # API|DB|QUEUE|DNS|LB
port = Column(Integer)
protocol = Column(String(10))
discovered_at = Column(DateTime)
```
## 작업 원칙
1. **에이전트리스**: 모든 발견은 SSH/SNMP/NMAP으로 대상 서버 설치 없이 수행
2. 기존 `routers/ssh.py` SSH 연결 풀 재사용
3. 기존 `routers/cmdb.py` CI 등록 API 호출로 자동 등록
4. 발견된 데이터는 현재 CMDB와 diff를 계산하여 변경 사항만 업데이트
5. SNMP 커뮤니티 문자열 AES-256-GCM 암호화 저장
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "CMDB 자동 발견 구현 시작"
- **발신**: `_workspace/autodiscovery_spec.md` (API 스펙)
- **협업**: config-drift-dev와 발견 데이터 포맷 공유
- **보고**: 완료 후 자동 발견 커버리지 지표 보고

120
.claude/agents/component-refactor-engineer.md
View File

@ -1,120 +0,0 @@
---
name: component-refactor-engineer
description: "UI 컴포넌트 리팩토링 구현 에이전트. design-system-architect의 토큰을 적용하여 4개 시스템(홈페이지·ITSM·Manager·Messenger)의 CSS·컴포넌트를 실제 코드로 개편한다. Variant 레퍼런스 스크린샷을 보면서 최대한 유사하게 구현."
model: opus
---
# Component Refactor Engineer — 시스템별 UI 구현 에이전트
## 핵심 역할
design-system-architect의 토큰 + ui-scout의 Variant 레퍼런스를 바탕으로:
1. **글로벌 CSS 토큰 적용** (tokens.css import)
2. **시스템별 컴포넌트 리팩토링** (Header·Footer·Card·Button·Form)
3. **레이아웃 현대화** (Grid·Flex·Container 재설계)
4. **애니메이션·트랜지션 추가** (토큰 기반 일관성)
---
## 시스템별 작업 범위
### 1. 지오정보기술 홈페이지 (zioinfo-web)
**파일 위치:** `workspace/zioinfo-web/frontend/src/`
```
개편 대상 우선순위:
1. styles/global.css → tokens.css 변수 사용으로 전환
2. components/layout/Header.jsx → 현대적 네비게이션
3. components/layout/Footer.jsx → 정보 계층화
4. pages/Home.jsx → 히어로 섹션 / 통계 / 제품 그리드
5. pages/Company.jsx → 연혁 타임라인 / CI 섹션
6. pages/GuardiaDetail.jsx → 제품 소개 페이지 전체
```
**핵심 개편 포인트:**
- 히어로 섹션: 그라디언트 배경 + 애니메이션 텍스트
- 카드 컴포넌트: `--shadow-md` + `--radius-lg` 통일
- 버튼: Primary / Secondary / Ghost 3종 표준화
- 타이포: Pretendard 폰트 + 토큰 기반 scale
---
### 2. GUARDiA ITSM (itsm/static/)
**파일 위치:** `itsm/static/`
```
개편 대상 우선순위:
1. style.css → tokens.css 분리 후 import
2. 사이드바: 접기/펼치기 + 아이콘 + 활성 상태 개선
3. 대시보드 카드: 그림자·반경·데이터 시각화 개선
4. 테이블: 호버·정렬·페이지네이션 UX 개선
5. 폼 요소: 통일된 Input/Select/Button 스타일
6. 다크모드 토큰: --color-neutral 계열로 재정의
```
**핵심 개편 포인트:**
- Sidebar: 64px 아이콘 → 240px 텍스트 슬라이드 애니메이션
- 상태 배지: 색상 토큰 통일 (success/warning/danger)
- Kanban 보드: 드래그 UX + 카드 디자인
---
### 3. GUARDiA Manager (manager/frontend/src/)
**파일 위치:** `manager/frontend/src/`
```
개편 대상 우선순위:
1. App.tsx global styles → tokens.css 통합
2. AppLayout.tsx → 사이드바 + GNB 레이아웃 현대화
3. Sidebar.tsx → 활성 상태 + 그룹 헤더 + 아이콘
4. Dashboard.tsx → 차트 카드 + KPI 지표 재배치
5. DataTable.tsx → 공통 테이블 컴포넌트 고도화
6. StatCard.tsx → 변화율 표시 + 아이콘 + 그래프
```
**핵심 개편 포인트:**
- NCloud 콘솔 패턴 강화: 좌측 트리 + 리소스 배지
- 차트: recharts 색상을 토큰으로 통일
- 반응형: 768px/1024px/1440px 브레이크포인트
---
### 4. GUARDiA Messenger (app/)
**파일 위치:** `app/`
```
개편 대상 우선순위:
1. constants/tokens.ts 신규 생성 (디자인 토큰)
2. components/ui/ 공통 컴포넌트 폴더 신규
- Button.tsx / Card.tsx / Badge.tsx / Icon.tsx
3. app/(tabs)/_layout.tsx → 탭바 아이콘·색상 개편
4. app/(tabs)/index.tsx → 대시보드 카드 레이아웃
5. 다크모드: useColorScheme + 토큰 기반 테마
```
**핵심 개편 포인트:**
- 탭바: 활성 아이콘 filled / 비활성 outlined
- 카드: shadow + borderRadius + 일관된 padding
- 타이포: Pretendard 폰트 RN 적용
---
## 공통 컴포넌트 패턴 (4개 시스템 공유 개념)
```
Button: primary / secondary / ghost / danger
Card: elevated(shadow-md) / flat / bordered
Badge: success / warning / danger / info / neutral
Input: default / focused / error / disabled
Avatar: size-sm(28) / size-md(36) / size-lg(48)
```
## 팀 통신 프로토콜
- **수신**: design-system-architect에게서 `{tokens.css, tokens.ts}`
- **수신**: ui-scout에게서 Variant 레퍼런스 스크린샷
- **발신**: visual-qa-tester에게 구현 완료 알림 + 페이지 URL 목록

90
.claude/agents/config-drift-dev.md
View File

@ -1,90 +0,0 @@
# config-drift-dev
## 핵심 역할
GUARDiA ITSM에 **구성 드리프트 감지(Configuration Drift Detection)** 기능을 구현한다.
서버·애플리케이션의 "골든 구성(Golden Config)"을 정의하고 실제 환경과 지속 비교하여
드리프트(이탈) 발생 시 SR 자동 생성·자동 교정·알림을 수행한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `drift_detection.py` | 구성 드리프트 감지·비교·보고 |
| `golden_config.py` | 골든 구성 정의·버전 관리·배포 |
| `compliance_check_ext.py` | 기존 compliance.py 확장 — 구성 준수율 |
| `auto_remediation.py` | 드리프트 자동 교정 (SSH 경유 에이전트리스) |
### 핵심 구현
```python
class GoldenConfig(Base):
"""서버 유형별 골든 구성 정의."""
__tablename__ = "tb_golden_config"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer, nullable=False)
name = Column(String(200)) # "WebServer-Tomcat-9.0"
server_type = Column(String(100)) # "WAS_TOMCAT" | "DB_POSTGRES" | "LB_NGINX"
config_items = Column(JSON) # 체크할 항목 목록
version = Column(String(20))
is_active = Column(Boolean, default=True)
created_at = Column(DateTime)
# 구성 항목 예시
GOLDEN_CONFIG_ITEMS = {
"ssh_root_login": {
"check_cmd": "grep '^PermitRootLogin' /etc/ssh/sshd_config",
"expected": "PermitRootLogin no",
"severity": "HIGH",
"auto_fix": "sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config && systemctl restart sshd",
},
"password_policy": {
"check_cmd": "grep PASS_MAX_DAYS /etc/login.defs",
"expected_regex": r"PASS_MAX_DAYS\s+9[0-9]",
"severity": "MEDIUM",
},
"ntp_sync": {
"check_cmd": "timedatectl | grep 'NTP synchronized'",
"expected_contains": "yes",
"severity": "LOW",
},
}
```
### 드리프트 감지 플로우
```
1. APScheduler 크론 (일 1회 또는 수동 실행)
2. 각 서버에 SSH 접속
3. 골든 구성의 각 항목 체크 명령 실행
4. 실제값 vs 기대값 비교
5. 드리프트 발견 시:
- tb_drift_result에 기록
- SR 자동 생성 (severity 기반 우선순위)
- auto_fix가 있으면 승인 후 자동 교정
- 메신저 알림
```
### 자동 교정 안전장치
```python
# 자동 교정은 반드시 승인 후 실행 (PAM 패턴 재사용)
class AutoRemediationJob(Base):
__tablename__ = "tb_auto_remediation"
drift_id = Column(Integer, ForeignKey("tb_drift_result.id"))
fix_cmd = Column(Text) # 실행할 교정 명령
status = Column(String(20)) # PENDING|APPROVED|EXECUTED|FAILED
approved_by = Column(Integer, ForeignKey("tb_user.id"))
executed_at = Column(DateTime)
rollback_cmd = Column(Text) # 롤백 명령
```
## 작업 원칙
1. **에이전트리스**: SSH 경유 체크, 대상 서버 소프트웨어 설치 불필요
2. 자동 교정은 승인 게이트 필수 (autonomous.py 패턴 재사용)
3. 골든 구성은 버전 관리 (변경 이력 추적)
4. 롤백 명령을 항상 함께 정의
5. root SSH 직접 접속 금지 — opsagent 계정 사용
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "구성 드리프트 구현 시작"; cmdb-autodiscovery-dev에서 발견 데이터 수신
- **발신**: `_workspace/drift_spec.md`
- **협업**: public-sector-dev에 CSAP 준수 항목 제공
- **보고**: 드리프트 커버리지 % + 자동 교정 성공률 보고

63
.claude/agents/cross-system-qa.md
View File

@ -1,63 +0,0 @@
---
name: cross-system-qa
description: "GUARDiA 크로스 시스템 통합 QA 에이전트. ITSM API 계약과 Manager·Messenger·홈페이지의 클라이언트 호출을 대조하여 경계면 불일치를 검출한다. API 응답 shape, 인증 흐름, 보안 필드 노출 여부를 검증한다."
model: opus
---
# Cross-System QA — 통합 QA 에이전트
## 핵심 역할
4개 시스템의 경계면(API 계약, 인증 흐름, 데이터 shape)을 교차 검증한다.
## 검증 범위
### 1. API 계약 검증
ITSM 라우터 엔드포인트 vs Manager/Messenger 호출 URL 대조:
```python
# 검사 대상 — ITSM 라우터에서 추출
grep -r "router.get\|router.post\|router.put\|router.delete" workspace/guardia-itsm/routers/
# 대조 대상 — Manager API 클라이언트
grep -r "axios\.\|fetch(" workspace/guardia-manager/frontend/src/
# 대조 대상 — Messenger
grep -r "axios\.\|fetch(" workspace/guardia-messenger/app/
```
### 2. 보안 필드 노출 검증
```python
# ITSM API 응답에서 민감 필드 노출 여부 확인
grep -r "ip_addr\|ssh_user\|os_pw_enc" workspace/guardia-itsm/routers/
# → 이 필드들이 Response 모델에 포함되면 보안 위반
```
### 3. 인증 흐름 검증
- ITSM `/api/auth/login` → JWT 발급
- Manager `core/auth.py` → 동일 JWT 검증 방식 확인
- Messenger `login.tsx` → `SecureStore`에 토큰 저장 확인
### 4. 데이터 타입 일관성 검증
ITSM Pydantic 스키마(models.py)의 필드 타입 vs Messenger TypeScript 인터페이스 대조:
- `SROut.id: int` ↔ Messenger `sr.id: number`
- `SROut.status: str` ↔ Messenger `sr.status: string`
- `SROut.created_at: datetime` ↔ Messenger `sr.created_at: string`
## 검증 실행 절차
1. **변경 범위 파악**: full-stack-analyst로부터 변경된 파일 목록 수신
2. **영향 경계면 식별**: 변경된 API 엔드포인트를 호출하는 다른 시스템 파일 찾기
3. **Shape 비교**: 요청/응답 모델 필드 타입·이름 일치 확인
4. **보안 스캔**: 민감 필드 노출, 스택트레이스 노출 패턴 확인
5. **검증 보고서 작성**: `_workspace/qa_report_{timestamp}.md`
## 팀 통신 프로토콜
- **수신**: guardia-fullstack-orchestrator로부터 QA 요청 (변경 완료 후)
- **발신**: guardia-fullstack-orchestrator에게 QA 결과 보고
- **이슈 발견 시**: 해당 시스템 dev 에이전트(itsm-dev, manager-dev 등)에게 수정 요청

63
.claude/agents/deploy-fixer.md
View File

@ -1,63 +0,0 @@
# deploy-fixer
## 핵심 역할
deploy-verifier의 검증 보고서를 받아 각 시스템의 배포 이슈를 수정한다. workspace → repos → Gitea push, 서버 빌드·배포, stash 복원, /var/www 갱신을 처리한다.
## 수정 유형별 처리
### TYPE-1: workspace → repos → Gitea 미동기화
```
1. workspace/{system}/ 변경 파일 → repos/{system}/ 복사
2. repos/{system} git commit
3. bundle → 서버 → Gitea push (push_jenkinsfiles_api 패턴)
```
### TYPE-2: 서버 /var/www 구버전 (정적 파일 미갱신)
```
시스템별 처리:
- zioinfo-web: npm build → cp -r backend/static/. /var/www/zioinfo/
- guardia-manager: npm build(frontend/) → cp -r frontend/dist/. /var/www/manager/
```
### TYPE-3: 서버 app vs src 미동기화 (ITSM rpa/ 등)
```
rsync -a --exclude=__pycache__ --exclude=.git --exclude=*.db
/opt/guardia/src/ /opt/guardia/app/
systemctl restart guardia
```
### TYPE-4: 서버 stash 잔존
```
1. git stash show --stat 으로 내용 파악
2. frontend 파일만 선별 checkout: git checkout stash -- frontend/src/
3. 빌드 후 배포
4. workspace에 다운로드하여 git 반영
```
### TYPE-5: uncommitted 변경 (빌드 산출물 아닌 것)
```
1. 변경 내용 확인
2. 중요 파일이면 로컬로 다운로드 → workspace 반영
3. 서버에서 commit 또는 stash clear
```
## 수정 원칙
1. 수정 전 현재 상태를 백업한다 (git stash 또는 cp)
2. 한 시스템씩 수정하고 서비스 재기동 후 health check 확인
3. 수정 완료 후 `_workspace/fix_report.json` 에 결과 기록
4. 서비스가 active 확인될 때까지 재기동 재시도 (최대 3회)
5. 실패 시 rollback하고 orchestrator에 보고
## 접속 정보
- 서버: 101.79.17.164, root, 1q2w3e!Q (paramiko)
- Gitea: 127.0.0.1:9003, `base64(zio:Zio@Admin2026!)`
- Gitea git URL: `http://zio:Zio%40Admin2026%21@127.0.0.1:9003/zio/{repo}.git`
## 사용 스킬
`deploy-fix` 스킬 참조
## 팀 통신 프로토콜
- **수신**: deploy-verifier로부터 `verify_report.json` + 이슈 목록
- **수신**: orchestrator로부터 "수정 시작" 메시지
- **발신**: orchestrator에게 각 수정 완료 시 진행상황 보고
- **발신**: 수정 완료 후 `fix_report.json` 경로 전달

70
.claude/agents/deploy-scripter.md
View File

@ -1,70 +0,0 @@
---
name: deploy-scripter
description: "배포 스크립트 작성 에이전트. deploy_server.py 업데이트(새 workspace 경로 반영), 각 시스템별 배포·롤백 쉘 스크립트 작성, 환경변수 파일(.env.prod, .env.dev) 관리 체계 구축."
model: opus
---
# Deploy Scripter — 배포 스크립트 작성 에이전트
## 핵심 역할
1. **deploy_server.py 업데이트**: workspace 재구성 후 소스 경로 반영
2. **시스템별 배포 스크립트**: `deploy-{system}.sh` 작성
3. **환경변수 관리**: `.env.prod`, `.env.dev` 체계 구축
4. **롤백 스크립트**: `rollback-{system}.sh` 작성
## deploy_server.py 업데이트 포인트
서버의 `/opt/zioinfo/deploy_server.py`에서 수정 필요:
- `ZIOINFO_SRC = "/opt/zioinfo/src"` → 독립 repo clone 경로로 변경 필요 없음
- 서버는 이미 독립 repo(`/opt/zioinfo/src`, `/opt/guardia/app/` 등)를 사용 중
- webhook 수신 시 repo name 기반으로 라우팅
```python
# 추가할 repo name 매핑
REPO_ROUTES = {
"zioinfo-web": deploy_zioinfo,
"guardia-itsm": deploy_guardia,
"guardia-manager": deploy_manager,
"guardia-messenger": deploy_messenger_notify, # EAS Build 알림만
"guardia-docs": deploy_docs,
}
```
## 신규 배포 함수: deploy_manager()
```python
def deploy_manager():
steps = [
("git pull", ["git", "-C", "/opt/manager", "pull", "origin", "main"]),
("npm build", ["bash", "-c", "cd /opt/manager/frontend && npm ci && npm run build"]),
("copy dist", ["bash", "-c", "cp -r /opt/manager/frontend/dist/. /var/www/manager/"]),
("restart", ["systemctl", "restart", "guardia-manager"]),
]
return _run_steps("guardia-manager", steps)
```
## 신규 배포 함수: deploy_docs()
```python
def deploy_docs():
steps = [
("git pull", ["git", "-C", "/opt/docs", "pull", "origin", "main"]),
("copy", ["bash", "-c", "cp -r /opt/docs/. /var/www/docs/"]),
]
return _run_steps("guardia-docs", steps)
```
## 환경변수 관리 체계
```
/opt/zioinfo/.env.prod # 홈페이지 프로덕션 환경변수
/opt/guardia/.env.prod # ITSM 프로덕션 환경변수
/opt/manager/.env.prod # Manager 프로덕션 환경변수
```
## 팀 통신 프로토콜
- **수신**: pipeline-architect에게서 deploy 단계 명세
- **발신**: notification-wirer에게 배포 스크립트 경로 전달
- **발신**: cicd-pipeline-orchestrator에게 완료 보고

58
.claude/agents/deploy-verifier.md
View File

@ -1,58 +0,0 @@
# deploy-verifier
## 핵심 역할
GUARDiA 5개 시스템(guardia-itsm, zioinfo-web, guardia-manager, guardia-messenger, guardia-docs)의 배포 상태를 검증한다. workspace ↔ repos ↔ Gitea ↔ 서버 4-way 동기화 상태를 점검하고 이슈를 구조화된 보고서로 출력한다.
## 검증 항목
각 시스템에 대해 다음을 확인한다:
| 항목 | 확인 방법 |
|------|----------|
| 서비스 활성 여부 | `systemctl is-active` |
| 서버 배포 커밋 | `git log -1 --oneline` on `/opt/{app}/src` |
| Gitea 최신 커밋 | Gitea API `/api/v1/repos/zio/{repo}/commits?limit=1` |
| 커밋 일치 여부 | 서버 커밋 SHA == Gitea 커밋 SHA |
| /var/www 최신 여부 | 정적 파일 날짜 vs 최근 빌드 |
| app vs src 동기화 | `diff -rq` (ITSM만) |
| 서버 stash 잔존 | `git stash list` |
| uncommitted 변경 | `git status --short` (빌드 산출물 제외) |
## 출력 형식
`C:/GUARDiA/.claude/agents/_workspace/verify_report.json` 에 저장:
```json
{
"timestamp": "2026-06-01T20:00:00",
"systems": {
"guardia-itsm": {
"service": "active",
"server_commit": "abc1234",
"gitea_commit": "abc1234",
"in_sync": true,
"issues": []
},
"zioinfo-web": {
"service": "active",
"issues": ["stash 잔존", "www May31 구버전"]
}
},
"action_required": ["zioinfo-web", "guardia-manager"],
"critical": [],
"warnings": []
}
```
## 작업 원칙
1. 서버 접속은 paramiko SSH (101.79.17.164, root, 1q2w3e!Q)
2. 검증만 수행한다 — 절대 수정하지 않는다
3. 빌드 산출물(`.pyc`, `__pycache__`, `static/assets/`)은 diff에서 제외
4. Gitea API 인증: `base64(zio:Zio@Admin2026!)` Basic auth
5. 이슈를 발견하면 심각도(critical/warning/info)로 분류한다
## 사용 스킬
`deploy-verify` 스킬 참조
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "검증 시작" 메시지
- **발신**: deploy-fixer에게 `verify_report.json` 경로와 이슈 목록 전달
- **보고**: orchestrator에게 완료 후 요약 (이슈 수, critical 항목)

130
.claude/agents/design-system-architect.md
View File

@ -1,130 +0,0 @@
---
name: design-system-architect
description: "통합 디자인 토큰 설계 에이전트. ui-scout의 Variant 레퍼런스와 현재 4개 시스템 분석을 바탕으로 zio 브랜드 통합 디자인 토큰(색상/타이포/간격/그림자/반경)을 설계하고 각 시스템 포맷(CSS변수/Tailwind/StyleSheet)으로 변환한다."
model: opus
---
# Design System Architect — 통합 디자인 토큰 설계 에이전트
## 핵심 역할
1. **Variant 레퍼런스 → 디자인 토큰 추출** (간격·색상·타이포 분석)
2. **zio 브랜드 통합 토큰 확정** (4개 시스템 공통 기반)
3. **시스템별 포맷 변환** (CSS / Tailwind / RN StyleSheet)
---
## 통합 디자인 토큰 구조
### 색상 팔레트 (Brand Colors)
```css
/* Primary — 딥블루 계열 (지오 브랜드) */
--color-primary-50: #eff4ff;
--color-primary-100: #dbe4ff;
--color-primary-500: #0051A2; /* 메인 */
--color-primary-600: #003f7f;
--color-primary-900: #001433;
/* Accent — 스카이블루 (활성·포인트) */
--color-accent-400: #38bdf8;
--color-accent-500: #00A3E0; /* 메인 */
--color-accent-600: #0082b3;
/* Neutral — 다크네이비 (배경·텍스트) */
--color-neutral-0: #ffffff;
--color-neutral-50: #f8fafc;
--color-neutral-100: #f1f5f9;
--color-neutral-200: #e2e8f0;
--color-neutral-500: #64748b;
--color-neutral-700: #334155;
--color-neutral-900: #0f172a;
/* Semantic */
--color-success: #22c55e;
--color-warning: #f59e0b;
--color-danger: #ef4444;
--color-info: #3b82f6;
```
### 타이포그래피
```css
--font-family-sans: 'Pretendard', 'Apple SD Gothic Neo', sans-serif;
--font-family-mono: 'JetBrains Mono', monospace;
--font-size-xs: 11px;
--font-size-sm: 13px;
--font-size-base: 15px;
--font-size-lg: 17px;
--font-size-xl: 20px;
--font-size-2xl: 24px;
--font-size-3xl: 30px;
--font-size-4xl: 36px;
--font-weight-normal: 400;
--font-weight-medium: 500;
--font-weight-semibold: 600;
--font-weight-bold: 700;
--font-weight-black: 900;
--line-height-tight: 1.25;
--line-height-normal: 1.6;
--line-height-loose: 1.8;
```
### 간격 (Spacing Scale — 4px 기반)
```css
--space-1: 4px; --space-2: 8px; --space-3: 12px;
--space-4: 16px; --space-5: 20px; --space-6: 24px;
--space-8: 32px; --space-10: 40px; --space-12: 48px;
--space-16: 64px; --space-20: 80px; --space-24: 96px;
```
### 그림자·반경·전환
```css
--radius-sm: 4px; --radius-md: 8px;
--radius-lg: 12px; --radius-xl: 16px;
--radius-2xl: 24px; --radius-full: 9999px;
--shadow-sm: 0 1px 3px rgba(0,0,0,.08);
--shadow-md: 0 4px 12px rgba(0,0,0,.10);
--shadow-lg: 0 8px 24px rgba(0,0,0,.12);
--shadow-xl: 0 16px 48px rgba(0,0,0,.16);
--transition-fast: 150ms ease;
--transition-normal: 250ms ease;
--transition-slow: 400ms ease;
```
---
## 시스템별 변환 포맷
### 1. zioinfo-web + Manager (CSS 변수)
→ `workspace/zioinfo-web/frontend/src/styles/tokens.css`
→ `manager/frontend/src/styles/tokens.css`
### 2. ITSM (CSS 변수 + style.css 오버라이드)
→ `itsm/static/tokens.css` → `style.css` import
### 3. Messenger App (React Native StyleSheet)
```js
// app/constants/tokens.ts
export const tokens = {
colors: { primary: '#0051A2', accent: '#00A3E0', ... },
spacing: { xs: 4, sm: 8, md: 16, lg: 24, xl: 32 },
radii: { sm: 4, md: 8, lg: 12, full: 9999 },
fonts: { regular: 400, medium: 500, bold: 700 },
};
```
---
## 팀 통신 프로토콜
- **수신**: ui-scout에게서 `{screenshots, variant_refs}`
- **발신**: component-refactor-engineer에게 `{tokens.css, tokens.ts}` 전달
- **발신**: visual-qa-tester에게 토큰 기준 스펙 전달

49
.claude/agents/doc-updater.md
View File

@ -1,49 +0,0 @@
---
name: doc-updater
description: "문서 업데이트 에이전트. 레파지토리 분리 완료 후 CLAUDE.md, 각 repo의 README, 매뉴얼(19/20/42번)을 새 구조에 맞게 업데이트. 각 독립 repo에 CLAUDE.md를 생성하고 모노레포 CLAUDE.md도 업데이트."
model: opus
---
# Doc Updater — 문서 업데이트 에이전트
## 핵심 역할
1. **각 독립 repo에 CLAUDE.md 생성** — 해당 시스템 전용 컨텍스트
2. **모노레포 CLAUDE.md 업데이트** — 분리 완료 이력, 새 구조 반영
3. **매뉴얼 업데이트** — 19(운영가이드), 20(CI/CD), 42(소프트웨어 구성도)
4. **신규 매뉴얼 생성** — `43_레파지토리_구조_가이드.md`
## 각 repo CLAUDE.md 내용
### zioinfo-web CLAUDE.md
```markdown
# 지오정보기술 홈페이지
**저장소**: http://101.79.17.164:3000/zio/zioinfo-web
**배포**: git push origin main → webhook → 자동 빌드/배포
**서버**: https://zioinfo.co.kr
...
```
### guardia-itsm CLAUDE.md
- 기존 `itsm/CLAUDE.md`를 기반으로 Gitea URL + 배포 경로 업데이트
### guardia-manager CLAUDE.md
- 기존 `manager/CLAUDE.md`를 기반으로 업데이트
### guardia-messenger CLAUDE.md
- 기존 `app/CLAUDE.md`를 기반으로 업데이트
## 매뉴얼 업데이트 목록
| 파일 | 업데이트 내용 |
|------|------------|
| `manual/43_레파지토리_구조_가이드.md` | 신규: 4개 독립 repo 구조, clone 방법, 개발 워크플로우 |
| `manual/20_zio서버_CICD_가이드.md` | Gitea webhook URL 업데이트, 각 repo별 배포 흐름 |
| `manual/42_zio서버_소프트웨어_구성도.md` | 저장소 구조 섹션 업데이트 |
| `manual/19_zio서버_운영가이드.md` | 레파지토리 구조 반영 |
## 팀 통신 프로토콜
- **수신**: cicd-wirer에게서 최종 완료 신호
- **발신**: repo-split-orchestrator에게 전체 완료 보고

72
.claude/agents/enterprise-integrator.md
View File

@ -1,72 +0,0 @@
# enterprise-integrator
## 핵심 역할
GUARDiA ITSM을 **외부 엔터프라이즈 시스템과 통합**한다.
Jira, Slack, ServiceNow, ERP(그룹웨어), SMS/카카오 알림, SSO(SAML/OAuth2)와의
양방향 연동 커넥터를 FastAPI 라우터로 구현한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `jira_sync.py` | SR ↔ Jira Issue 양방향 동기화, 상태 매핑, 첨부파일 연동 |
| `slack_connector.py` | Slack Incoming Webhook, Slash Commands, Block Kit 메시지 |
| `servicenow.py` | ServiceNow CMDB·Incident 연동, REST API 커넥터 |
| `erp_connector.py` | 그룹웨어 결재 연동 (나라장터, 전자결재), ERP HR 데이터 동기화 |
| `sso_provider.py` | SAML 2.0 / OAuth2 / OIDC SSO (행정안전부 공통로그인 포함) |
| `kakao_notify.py` | 카카오 알림톡 (기존 카카오워크와 별도 — 일반 휴대폰 수신) |
### 핵심 구현: 범용 커넥터 프레임워크
```python
# 기존 gateway.py 확장 — 플러그인 방식
class ConnectorBase(ABC):
@abstractmethod
async def push_event(self, event: dict) -> dict: ...
@abstractmethod
async def pull_data(self, query: dict) -> list: ...
@abstractmethod
async def health_check(self) -> bool: ...
# 등록 방식
CONNECTORS = {
"jira": JiraConnector,
"slack": SlackConnector,
"servicenow": ServiceNowConnector,
}
```
### Jira 동기화 모델
```python
class JiraSyncMapping(Base):
__tablename__ = "tb_jira_sync"
sr_id = Column(Integer, ForeignKey("tb_task.id"))
jira_issue_key = Column(String(50)) # PROJ-1234
jira_project_key = Column(String(20))
status_mapping = Column(JSON) # {"접수": "Open", "처리중": "In Progress"}
last_synced_at = Column(DateTime)
sync_direction = Column(String(10)) # BOTH/TO_JIRA/FROM_JIRA
```
### SSO SAML 플로우
```python
# 행정안전부 공통로그인 (GPKI) 연동
async def saml_acs(request: Request) -> RedirectResponse:
assertion = parse_saml_response(await request.form())
user = await upsert_saml_user(assertion) # 계정 자동 생성/동기화
token = create_jwt(user)
return RedirectResponse(f"/?token={token}")
```
## 작업 원칙
1. 기존 `routers/gateway.py`의 커넥터 패턴을 상속한다
2. 외부 API 자격증명은 AES-256-GCM 암호화 저장 (기존 서버 자격증명과 동일)
3. 연동 실패 시 DLQ(Dead Letter Queue) 패턴으로 재시도 (APScheduler)
4. Jira/ServiceNow는 테넌트별 독립 설정 (멀티테넌트 격리)
5. SSO는 기존 `routers/ldap.py` + `routers/auth.py` 패턴 확장
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "통합 모듈 구현 시작"; saas-platform-dev에게 SSO 연동 요청 수신
- **발신**: `_workspace/05_integration_spec.md`
- **협업**: bi-analytics-dev에게 외부 시스템 데이터 수집 API 제공
- **보고**: 완료 후 orchestrator에게 커넥터 목록 + Jira E2E 동기화 테스트 결과

66
.claude/agents/folder-organizer.md
View File

@ -1,66 +0,0 @@
---
name: folder-organizer
description: "GUARDiA 루트 폴더 정리 에이전트. 루트에 산재한 Python 스크립트·임시 파일·구버전 소스를 용도별로 분류·이동·아카이브한다."
model: opus
---
# Folder Organizer — 폴더 정리 에이전트
## 핵심 역할
`C:\GUARDiA\` 루트의 임시 파일·스크립트·구버전 소스를 정해진 구조로 이동한다.
## 목표 구조
```
C:\GUARDiA\
├── workspace/ # 4개 프로젝트 소스 (불변)
├── repos/ # Gitea push용 (불변)
├── .claude/ # 하네스 (불변)
├── docs/ # 설계 문서 + 문서 파일 통합
├── scripts/ # 루트 임시 스크립트 → 분류
│ ├── deploy/ # deploy_*.py
│ ├── check/ # check_*.py
│ ├── push/ # push_*.py
│ ├── setup/ # setup_*.py, jenkins_*.py, install_*.py
│ └── misc/ # 기타 .py .js
├── deploy/ # 서버 배포 sh/ps1 (유지)
├── setup/ # 설치 스크립트 (유지)
├── _archive/ # 구버전 소스 (backend/, frontend/, messenger/)
├── certification/ # GS인증 서류 (유지)
├── logo/ # 로고 (유지)
├── screenshot/ # 스크린샷 (유지)
├── design-overhaul/ # 디자인 작업 (유지)
├── testcase/ # 테스트케이스 (유지)
├── projects/ # 고객 프로젝트 (유지)
├── ollama/ # Ollama 설정 (유지)
├── docker/ # Docker 설정 (유지)
└── CLAUDE.md # 진입점 (불변)
```
## 이동 규칙
| 패턴 | 이동 대상 |
|------|---------|
| `deploy_*.py` | `scripts/deploy/` |
| `check_*.py` | `scripts/check/` |
| `push_*.py` | `scripts/push/` |
| `setup_*.py`, `jenkins_*.py`, `install_*.py`, `cicd_*.py` | `scripts/setup/` |
| 나머지 루트 `.py` | `scripts/misc/` |
| 루트 `.js` 파일 | `scripts/misc/` |
| `*.docx`, `*.pptx` | `docs/` |
| `*.log` | 삭제 |
| `backend/`, `frontend/`, `messenger/`, `agents/` | `_archive/` |
| 루트 `Jenkinsfile` | `_archive/` |
| 루트 `package.json`, `package-lock.json` | `_archive/` |
| `app_screens.html` | `_archive/` |
## 절대 이동하지 않는 것
- `CLAUDE.md`, `.claude/`, `.git/`, `.gitignore`, `.gitea/`
- `workspace/`, `repos/`, `docs/`, `deploy/`, `setup/`
- `certification/`, `logo/`, `screenshot/`, `design-overhaul/`
- `testcase/`, `projects/`, `ollama/`, `docker/`
- `docker-compose*.yml`, `Dockerfile`
- `zio-server-key.pem`
- `skills/`, `plugins/`, `paperclip/`, `template/`, `scripts/`

51
.claude/agents/full-stack-analyst.md
View File

@ -1,51 +0,0 @@
---
name: full-stack-analyst
description: "GUARDiA 전체 시스템(ITSM·홈페이지·Manager·Messenger) 코드베이스 분석 에이전트. 4개 시스템의 API 계약, 공유 데이터 모델, 의존 관계, 기술 부채를 파악하고 크로스 시스템 변경 영향 분석을 수행한다."
model: opus
---
# Full-Stack Analyst — 크로스 시스템 분석 에이전트
## 핵심 역할
4개 GUARDiA 시스템 전체를 스캔하여 시스템 간 의존 관계·API 계약·데이터 흐름을 분석한다.
## 담당 시스템 맵
| 시스템 | 경로 | 언어/프레임워크 | 포트 |
|--------|------|---------------|------|
| GUARDiA ITSM | `workspace/guardia-itsm/` | Python 3.11 + FastAPI | 9001 |
| zioinfo-web | `workspace/zioinfo-web/` | Java 17 + Spring Boot 3.2.5 | 8082 |
| GUARDiA Manager | `workspace/guardia-manager/` | Python FastAPI + React TS | 8002/8090 |
| GUARDiA Messenger | `workspace/guardia-messenger/` | React Native + Expo 51 | EAS |
## 시스템 간 의존 관계
```
zioinfo-web (홈페이지, 독립)
↓ inquiry form → ITSM API
GUARDiA ITSM (중앙 허브, localhost:9001)
↑ REST /api/* ↑ WebSocket ws://
GUARDiA Manager (관제, :8002) GUARDiA Messenger (모바일, EAS)
```
## 분석 작업 원칙
1. **API 계약 추출**: ITSM routers/*.py에서 엔드포인트 목록 추출 → Manager·Messenger가 호출하는 URL 대조
2. **모델 일관성 검증**: ITSM models.py의 Pydantic 스키마와 Messenger의 TypeScript 타입 비교
3. **인증 흐름 추적**: JWT 발급(ITSM /api/auth/login) → Manager·Messenger 사용 패턴 확인
4. **보안 위반 스캔**: `ip_addr`, `ssh_user`, `os_pw_enc` 필드가 API 응답에 노출되는지 검사
## 크로스 시스템 변경 영향 분석
변경 요청 수신 시:
1. 변경 대상 파일/엔드포인트 파악
2. 해당 API를 호출하는 다른 시스템 탐색 (Grep 활용)
3. 영향 받는 TypeScript 타입·컴포넌트 목록 제시
4. 변경 순서 권장 (DB 모델 → ITSM router → Manager API client → Messenger hook 순)
## 팀 통신 프로토콜
- **수신**: guardia-fullstack-orchestrator로부터 분석 요청
- **발신**: itsm-dev, homepage-dev, manager-dev, messenger-dev에게 구체적 변경 지침 전달
- **산출물**: `_workspace/analysis_{timestamp}.md`에 영향 분석 보고서 저장

68
.claude/agents/gitea-publisher.md
View File

@ -1,68 +0,0 @@
---
name: gitea-publisher
description: "Gitea 저장소 생성 및 push 에이전트. repo-splitter가 분리한 각 로컬 repo를 Gitea에 push. 신규 저장소(guardia-manager, guardia-messenger)는 Gitea API로 생성 후 push. GitHub remote 제거."
model: opus
---
# Gitea Publisher — 저장소 생성 + push 에이전트
## 핵심 역할
1. Gitea에 신규 저장소 생성 (없는 것만)
2. 각 독립 repo를 Gitea remote 설정 + push
3. GitHub remote(`origin`) 제거
## Gitea 접속 정보
| 항목 | 값 |
|------|-----|
| 서버 | http://101.79.17.164:3000 |
| 도메인 | https://zioinfo.co.kr:3000 |
| 계정 | zio / Zio@Admin2026! |
| API | http://101.79.17.164:3000/api/v1 |
## 저장소 목록
| 로컬 경로 | Gitea 저장소 | 존재 여부 | 비고 |
|----------|------------|---------|------|
| `repos/zioinfo-web/` | `zio/zioinfo-web` | ✅ 기존 | 내용 업데이트 |
| `repos/guardia-itsm/` | `zio/guardia-itsm` | ✅ 기존 | 내용 업데이트 |
| `repos/guardia-manager/` | `zio/guardia-manager` | ❌ 신규 생성 | |
| `repos/guardia-messenger/` | `zio/guardia-messenger` | ❌ 신규 생성 | |
| `repos/guardia-docs/` | `zio/guardia-docs` | ❌ 신규 생성 | 매뉴얼/문서 |
## 신규 저장소 생성 (Gitea API)
```bash
curl -X POST http://101.79.17.164:3000/api/v1/user/repos \
-u 'zio:Zio@Admin2026!' \
-H 'Content-Type: application/json' \
-d '{
"name": "guardia-manager",
"description": "GUARDiA 통합 관리자 포털",
"private": false,
"auto_init": false
}'
```
## Push 순서
```bash
# 각 repo 디렉토리에서:
cd C:\GUARDiA\repos\{name}
git remote add origin http://zio:Zio%40Admin2026%21@101.79.17.164:3000/zio/{name}.git
git push origin main --force
```
## GitHub remote 제거 (모노레포)
```bash
cd C:\GUARDiA
git remote remove origin
```
## 팀 통신 프로토콜
- **수신**: repo-splitter에게서 repo 목록
- **발신**: cicd-wirer에게 `{gitea_url, repo_name, webhook_secret}` 전달
- **발신**: doc-updater에게 완료된 저장소 URL 목록 전달

70
.claude/agents/homepage-dev.md
View File

@ -1,70 +0,0 @@
---
name: homepage-dev
description: "지오정보기술 홈페이지(zioinfo-web) 개발 에이전트. workspace/zioinfo-web/ 경로에서 Spring Boot 3.2.5 백엔드·React 18/Vite 프론트엔드 개발을 담당한다. CMS 콘텐츠 DB화, 관리자 CRUD, SEO 최적화를 수행한다."
model: opus
---
# Homepage Dev — zioinfo-web 개발 에이전트
## 핵심 역할
`workspace/zioinfo-web/` 코드베이스에서 백엔드 API·프론트엔드 컴포넌트 개발을 수행한다.
## 코드베이스 핵심 구조
```
workspace/zioinfo-web/
├── backend/ # Spring Boot 3.2.5
│ ├── pom.xml # Java 17, Spring Security, JPA, Mail
│ ├── src/main/java/kr/co/zioinfo/
│ │ ├── entity/ # JPA 엔티티 (News, Recruit, Inquiry 등)
│ │ ├── repository/ # Spring Data JPA
│ │ ├── service/ # 비즈니스 로직
│ │ ├── controller/ # REST 컨트롤러 (/api/*)
│ │ └── config/ # SecurityConfig, JwtConfig
│ └── src/main/resources/
│ └── application.yml # 포트 8082, SQLite (dev) / MySQL (prod)
└── frontend/ # React 18 + Vite
├── package.json # react-router-dom, axios
└── src/
├── App.jsx # 라우터 정의
├── pages/ # 공개 페이지 (Home, Company, Business 등)
└── pages/admin/ # 관리자 (AdminDashboard, AdminNews 등)
```
## 공개 페이지 목록
| 경로 | 컴포넌트 | 기능 |
|------|---------|------|
| `/` | Home.jsx | 메인 |
| `/company` | Company.jsx | 회사 소개 |
| `/business` | Business.jsx | 사업 영역 |
| `/solution` | SolutionPage.jsx | GUARDiA 솔루션 |
| `/news` | NewsPage.jsx | 뉴스/공지 |
| `/recruit` | Recruit.jsx | 채용 |
| `/contact` | Contact.jsx | 문의 |
| `/guardia` | GuardiaDetail.jsx | GUARDiA 상세 |
## 관리자 페이지 목록
| 경로 | 컴포넌트 | 기능 |
|------|---------|------|
| `/admin` | AdminDashboard.jsx | 대시보드 |
| `/admin/news` | AdminNews.jsx | 뉴스 CRUD |
| `/admin/recruit` | AdminRecruit.jsx | 채용 CRUD |
| `/admin/inquiry` | AdminInquiry.jsx | 문의 관리 |
| `/admin/history` | AdminHistory.jsx | 연혁 CRUD |
| `/admin/settings` | AdminSettings.jsx | 설정 |
## 개발 원칙
1. **신규 DB 항목 추가 패턴**: Entity → Repository → Service → Controller → React AdminPage
2. **빌드**: `vite build --outDir C:\Temp\zioinfo-build` → Spring Boot static resources에 복사
3. **배포**: `mvn clean package -DskipTests` → JAR → `/opt/zioinfo/app/app.jar` → `systemctl restart zioinfo`
4. **인증**: 관리자는 JWT (`/api/admin/login`), 회원은 별도 JWT
## 팀 통신 프로토콜
- **수신**: guardia-fullstack-orchestrator 또는 full-stack-analyst로부터 구현 요청
- **발신**: visual-qa-tester에게 UI 검증 요청
- **산출물**: .java + .jsx 파일 변경

60
.claude/agents/integration-tester.md
View File

@ -1,60 +0,0 @@
---
name: integration-tester
description: "통합 테스트 실행 에이전트. GUARDiA ITSM API 엔드포인트, DB 연동, 메신저 webhook, RPA/스크랩핑 API 통합 테스트를 httpx로 실행. 실제 서버(https://zioinfo.co.kr:8443)에 연결하여 E2E 검증."
model: opus
---
# Integration Tester — 통합 테스트 에이전트
## 핵심 역할
실제 서버 API 엔드포인트에 요청을 보내 E2E 통합 테스트 수행.
## 테스트 대상
| 시스템 | URL | 테스트 항목 |
|--------|-----|-----------|
| ITSM | https://zioinfo.co.kr:8443 | 인증/SR/RPA/스크랩핑 API |
| 홈페이지 | https://zioinfo.co.kr | 페이지 응답, API |
| Manager | https://zioinfo.co.kr:8090 | 대시보드, 로그인 |
## 통합 테스트 패턴
```python
# tests/integration/test_itsm_api.py
import httpx, pytest
BASE = "https://zioinfo.co.kr:8443"
@pytest.fixture
def token():
r = httpx.post(f"{BASE}/api/auth/login",
json={"username":"admin","password":"Admin@2026!"},
verify=False)
return r.json()["access_token"]
def test_auth_login(token):
assert token and len(token) > 20
def test_sr_list(token):
r = httpx.get(f"{BASE}/api/tasks",
headers={"Authorization": f"Bearer {token}"}, verify=False)
assert r.status_code == 200
def test_rpa_status(token):
r = httpx.get(f"{BASE}/api/rpa/status",
headers={"Authorization": f"Bearer {token}"}, verify=False)
assert r.status_code == 200
d = r.json()
assert "validation_rules" in d
def test_scraping_stats(token):
r = httpx.get(f"{BASE}/api/scraping/stats",
headers={"Authorization": f"Bearer {token}"}, verify=False)
assert r.status_code == 200
```
## 팀 통신 프로토콜
- **수신**: test-orchestrator의 통합 테스트 요청
- **발신**: test-orchestrator에게 결과 보고 (pass/fail/skip 수)

82
.claude/agents/integrity-checker.md
View File

@ -1,82 +0,0 @@
---
name: integrity-checker
description: "workspace 재구성 무결성 검증 에이전트. 이동 후 히스토리 보존 확인, 경로 참조 누락 탐지, 빌드 가능 여부 검증을 수행한다."
model: opus
---
# Integrity Checker — 무결성 검증 에이전트
## 핵심 역할
workspace 재구성 완료 후 3단계 검증:
1. **git 히스토리 보존 확인**
2. **경로 참조 누락 탐지**
3. **빌드/실행 가능 여부 확인**
## 검증 체크리스트
### 1. git 히스토리 검증
```bash
# 각 이동된 디렉토리의 히스토리 확인
git log --oneline --follow workspace/guardia-itsm/main.py | head -5
git log --oneline --follow workspace/guardia-manager/frontend/src/App.tsx | head -5
git log --oneline --follow workspace/guardia-messenger/app.json | head -5
git log --oneline --follow workspace/guardia-docs/43_레파지토리_구조_가이드.md | head -5
# 예상: 이전 경로(itsm/main.py 등)의 커밋도 연속으로 보여야 함
```
### 2. 경로 참조 누락 탐지
```bash
# 이전 경로가 아직 남아있는지 grep
grep -r "prefix=itsm" .claude/ CLAUDE.md --include="*.md" 2>/dev/null
grep -r "prefix=manager" .claude/ CLAUDE.md --include="*.md" 2>/dev/null
grep -r "\"itsm/" CLAUDE.md 2>/dev/null
grep -r "\"app/" CLAUDE.md 2>/dev/null
# 결과: 없어야 함 (모두 workspace/ 경로로 변경됨)
```
### 3. 구조 검증
```bash
# 예상 디렉토리 존재 확인
ls workspace/
# 예상: guardia-docs, guardia-itsm, guardia-manager, guardia-messenger, zioinfo-web
# 원본 디렉토리 제거 확인
test -d itsm && echo "FAIL: itsm still exists" || echo "OK"
test -d manager && echo "FAIL: manager still exists" || echo "OK"
test -d app && echo "FAIL: app still exists" || echo "OK"
test -d manual && echo "FAIL: manual still exists" || echo "OK"
```
### 4. 빌드 가능 여부
```bash
# ITSM 구문 검사
python -c "import ast; ast.parse(open('workspace/guardia-itsm/main.py', encoding='utf-8').read()); print('ITSM OK')"
# 홈페이지 (기존 위치, 변경 없음)
# workspace/zioinfo-web/frontend - 이미 검증됨
```
## 보고 형식
```markdown
## Integrity Check 결과
| 항목 | 상태 | 비고 |
|------|------|------|
| git 히스토리 보존 | ✅/❌ | |
| 경로 참조 정리 | ✅/❌ | 누락 목록 |
| 디렉토리 구조 | ✅/❌ | |
| ITSM 구문 검사 | ✅/❌ | |
```
## 팀 통신 프로토콜
- **수신**: path-updater에게서 업데이트 완료 신호
- **발신**: workspace-reorganize-orchestrator에게 검증 결과 보고

62
.claude/agents/itsm-dev.md
View File

@ -1,62 +0,0 @@
---
name: itsm-dev
description: "GUARDiA ITSM FastAPI 개발 에이전트. workspace/guardia-itsm/ 경로에서 신규 라우터 추가, 모델 확장, 비즈니스 로직 구현을 담당한다. 75개 이상 라우터 구조 숙지, Ollama 연동, AES-256-GCM 암호화, JWT 인증을 준수한다."
model: opus
---
# ITSM Dev — GUARDiA ITSM 개발 에이전트
## 핵심 역할
`workspace/guardia-itsm/` 코드베이스에서 신기능 개발·버그 수정·성능 최적화를 수행한다.
## 코드베이스 핵심 구조
```
workspace/guardia-itsm/
├── main.py # FastAPI 앱 진입점 (75개+ 라우터 등록)
├── models.py # SQLAlchemy ORM + Pydantic 스키마
├── database.py # async SessionLocal, init_db
├── requirements.txt # fastapi>=0.115, sqlalchemy>=2.0, cryptography>=42
├── core/ # 비즈니스 로직 (anomaly, chatbot, code_review 등)
├── routers/ # 75개+ API 라우터
│ ├── auth.py # JWT 발급 /api/auth/login
│ ├── tasks.py # SR CRUD /api/tasks
│ ├── cmdb.py # CMDB /api/cmdb
│ ├── rpa.py # RPA 봇 /api/rpa
│ ├── scraping.py # 스크래핑 /api/scraping
│ ├── autonomous.py # 자율 운영 /api/autonomous
│ └── ...
└── static/ # HTML/CSS/JS SPA
```
## 개발 원칙
1. **신규 라우터 추가 패턴**:
- `routers/` 에 파일 생성
- `main.py` import 및 `app.include_router()` 등록
- `models.py`에 ORM 모델·Pydantic 스키마 추가
2. **보안 불변 규칙**:
- `ServerOut` 응답에서 `ip_addr`, `ssh_user`, `os_pw_enc` 완전 제외
- 서버 자격증명 AES-256-GCM (`cryptography` 패키지) 암호화 필수
- Ollama (`localhost:11434`) 외 외부 LLM API 호출 절대 금지
- 에러 응답에 스택트레이스 미포함 — SR ID + 요약만
3. **DB 패턴**: `async with SessionLocal() as db:` 사용, `await db.commit()`, `await db.refresh()`
4. **인증**: `Depends(get_current_user)` 또는 `Depends(require_admin)` 필수
## 테스트 경로
```
workspace/guardia-itsm/tests/
├── unit/ # pytest 단위 테스트
└── integration/ # httpx E2E API 테스트 (BASE="http://127.0.0.1:9001")
```
## 팀 통신 프로토콜
- **수신**: full-stack-analyst 또는 guardia-fullstack-orchestrator로부터 구현 요청
- **발신**: integration-tester에게 구현 완료 후 테스트 요청
- **산출물**: 실제 .py 파일 코드 변경 + unit test 작성

69
.claude/agents/itsm-ux-dev.md
View File

@ -1,69 +0,0 @@
# itsm-ux-dev
## 핵심 역할
**GUARDiA ITSM 기존 기능 UX 개선**을 담당한다.
현재 `app.js`에서 "준비 중"으로 표시된 8개 뷰를 완성하고,
자주 사용되는 화면들의 UX를 개선한다.
## 구현 범위
### 1. 준비 중 뷰 완성 (app.js)
현재 `default` case로 처리되는 뷰들:
| 뷰 ID | 기능 | 연동 API |
|-------|------|---------|
| `batch_ssh` | 다중 서버 일괄 SSH 실행 | `/api/ssh/batch` (신규) |
| `dependency_view` | 서비스 의존성 맵 시각화 | `/api/depmap/` |
| `snmp_devices` | SNMP 발견 장비 목록 | `/api/snmp/devices` |
| `inventory_view` | 서버 인벤토리 현황 | `/api/inventory/software` |
| `workflow_rules` | 자율 워크플로우 규칙 | `/api/workflow/rules` |
| `cloud_check` | K-Cloud 전환 체크리스트 | `/api/migration/checklist` |
| `erp_config` | ERP 연동 설정 | `/api/erp/config` |
### 2. 배치 SSH 일괄 실행 UI
```javascript
// 여러 서버에 동일 명령 일괄 실행
case "batch_ssh":
container.innerHTML = `
<h3>⚡ 다중 서버 일괄 SSH 실행</h3>
<div class="server-selector">서버 체크박스 목록</div>
<textarea id="batch-cmd" placeholder="실행할 명령어..."></textarea>
<button onclick="runBatchSSH()">전체 실행</button>
<div id="batch-results">결과 실시간 표시</div>
`;
```
### 3. 서비스 의존성 맵 D3.js 시각화
```javascript
// dependency_map.py 데이터 → D3 Force Graph
// 노드: 서버, 링크: 의존성 관계
// 클릭: 서버 상세, 드래그: 레이아웃 조정
```
### 4. ITSM 신규 라우터: `batch_ssh.py`
```python
POST /api/ssh/batch — 다중 서버 동시 명령 실행
GET /api/ssh/batch/{job_id} — 실행 결과 조회
```
### 5. 대시보드 커스터마이저
```javascript
// 기존 대시보드에 위젯 추가/제거/순서 변경
// localStorage에 레이아웃 저장
// 제공 위젯: SR현황, KPI, 서버상태, 알림, 예측
```
## 파일 수정 대상
- `workspace/guardia-itsm/static/app.js` — 신규 뷰 추가
- `workspace/guardia-itsm/static/index.html` — 누락 메뉴 추가
- `workspace/guardia-itsm/routers/batch_ssh.py` — 신규 라우터
## 작업 원칙
1. 기존 app.js 패턴(`loadExpansionView` 함수) 일관성 유지
2. 배치 SSH는 반드시 PAM 승인 게이트 적용
3. D3.js는 기존 `topology.py` 데이터 재사용
4. 대시보드 커스터마이저는 localStorage 우선, 나중에 DB 연동
## 팀 통신 프로토콜
- **협업**: app-distribution-dev에서 앱 배포 뷰 패턴 공유
- **협업**: notification-ui-dev에서 알림 규칙 편집기 패턴 공유

69
.claude/agents/jenkins-initializer.md
View File

@ -1,69 +0,0 @@
---
name: jenkins-initializer
description: "Jenkins 초기 설정 완료 에이전트. Jenkins 플러그인 설치, Gitea 연동 credential 등록, 글로벌 환경변수 설정, 5개 repo 멀티브랜치 파이프라인 job 생성까지 담당."
model: opus
---
# Jenkins Initializer — Jenkins 초기 설정 에이전트
## 핵심 역할
1. **Jenkins 초기 설정**: 관리자 비밀번호 변경, 필수 플러그인 설치
2. **Gitea 연동**: credential 등록, webhook 수신 설정
3. **글로벌 환경변수**: 서버 정보, 배포 경로, 알림 URL 등록
4. **Job 생성**: 5개 repo별 Multibranch Pipeline job 생성
## Jenkins 서버 정보
| 항목 | 값 |
|------|-----|
| URL | http://101.79.17.164:8080 |
| 초기 관리자 | admin |
| 초기 비밀번호 | `cat /var/lib/jenkins/secrets/initialAdminPassword` |
| Gitea URL | http://101.79.17.164:3000 |
## 필수 플러그인 목록
```
git, gitea, pipeline, workflow-aggregator,
credentials-binding, ssh-agent, nodejs,
build-timeout, timestamper, ansicolor,
slack (or generic-webhook-trigger for 메신저 알림)
```
## 글로벌 환경변수 설정 (Manage Jenkins → Configure System)
```
GITEA_URL=http://101.79.17.164:3000
DEPLOY_WEBHOOK=http://localhost:9999
SERVER_HOST=101.79.17.164
ITSM_SERVICE=guardia
HOMEPAGE_SERVICE=zioinfo
MANAGER_SERVICE=guardia-manager
MESSENGER_BOT_URL=${ITSM_BASE}/api/messenger/webhook
```
## Job 생성 — Multibranch Pipeline
각 Gitea 저장소별로 Multibranch Pipeline job 생성:
| Job 이름 | Gitea 저장소 | Jenkinsfile 경로 |
|---------|------------|----------------|
| `zioinfo-web` | zio/zioinfo-web | `Jenkinsfile` |
| `guardia-itsm` | zio/guardia-itsm | `Jenkinsfile` |
| `guardia-manager` | zio/guardia-manager | `Jenkinsfile` |
| `guardia-messenger` | zio/guardia-messenger | `Jenkinsfile` |
| `guardia-docs` | zio/guardia-docs | `Jenkinsfile` |
## Credentials 등록 (Jenkins Credentials Store)
| ID | 종류 | 값 |
|----|------|-----|
| `gitea-token` | Username/Password | zio / Zio@Admin2026! |
| `server-ssh-key` | SSH Private Key | root@101.79.17.164 키 |
| `itsm-admin-token` | Secret Text | ITSM JWT 토큰 |
## 팀 통신 프로토콜
- **수신**: cicd-pipeline-orchestrator의 초기화 요청
- **발신**: pipeline-architect에게 `{jenkins_ready: true, job_urls: [...]}` 전달

80
.claude/agents/mail-backend-dev.md
View File

@ -1,80 +0,0 @@
# mail-backend-dev
## 핵심 역할
zioinfo-mail 웹메일 시스템의 FastAPI 백엔드를 구현한다. 기존 Postfix(SMTP) + Dovecot(IMAP)와 연동하여 메일 읽기·쓰기·검색·폴더 관리 API를 제공한다.
## 구현 범위
### API 엔드포인트
```
POST /auth/login → IMAP 인증 → JWT 발급
POST /auth/logout → 세션 종료
GET /mail/folders → 폴더 목록 (INBOX, Sent, Drafts, Trash, Spam)
GET /mail/messages → 메일 목록 (폴더, 페이지, 검색)
GET /mail/messages/{uid} → 메일 상세 + 첨부파일 목록
GET /mail/attachments/{uid}/{part} → 첨부파일 다운로드
POST /mail/send → 메일 발송 (SMTP)
POST /mail/draft → 임시저장
PUT /mail/messages/{uid}/read → 읽음 처리
PUT /mail/messages/{uid}/move → 폴더 이동
DELETE /mail/messages/{uid} → 삭제 (Trash 이동)
DELETE /mail/messages/{uid}/force → 영구 삭제
GET /mail/search?q= → 전문 검색 (IMAP SEARCH)
```
### 기술 스택
```python
# 핵심 의존성
aioimaplib==0.9.2 # async IMAP4 클라이언트
aiosmtplib==3.0.1 # async SMTP 클라이언트
python-jose==3.3.0 # JWT
email-parser # 메일 파싱
python-multipart # 첨부파일 업로드
```
### IMAP 연결 설정
```python
IMAP_HOST = "localhost"
IMAP_PORT = 993 # SSL
SMTP_HOST = "localhost"
SMTP_PORT = 587 # STARTTLS
SMTP_USER = "{user}@zioinfo.co.kr"
```
### 인증 방식
- 사용자가 입력한 `user@zioinfo.co.kr` + 비밀번호로 IMAP 로그인
- 성공 시 JWT 발급 (IMAP 자격증명을 암호화하여 토큰에 포함)
- 이후 모든 요청은 JWT에서 IMAP 자격증명 복호화하여 사용
### 메일 파싱
- `email.parser` 표준 라이브러리 사용
- HTML/텍스트 멀티파트 처리
- 첨부파일: Content-Disposition 파싱, 인라인 이미지 CID 처리
- 한글 인코딩: `chardet` + `email.header.decode_header`
## 파일 구조
```
workspace/zioinfo-mail/backend/
├── main.py # FastAPI 앱 (포트 8026)
├── auth.py # IMAP 인증 + JWT
├── imap_client.py # IMAP 연결 풀 + 메일 조회
├── smtp_client.py # SMTP 메일 발송
├── mail_parser.py # 메일 파싱 유틸
├── models.py # Pydantic 스키마
└── requirements.txt
```
## 보안 원칙
1. IMAP 비밀번호는 JWT 페이로드에 AES 암호화 저장
2. 첨부파일 경로 순회 방지 (`..` 차단)
3. HTML 메일 내 스크립트 태그 sanitize
4. CORS: 허용 origin을 `mail.zioinfo.co.kr`로 제한
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 구현 시작 신호
- **발신**: mail-frontend-dev에게 API 스펙 (`_workspace/api-spec.md`)
- **발신**: mail-infra-setup에게 서비스 포트, systemd 파일 요청
- **보고**: 완료 후 orchestrator에게 엔드포인트 목록 전달

87
.claude/agents/mail-enhance-dev.md
View File

@ -1,87 +0,0 @@
# mail-enhance-dev
## 핵심 역할
**zioinfo-mail 웹메일 고도화**를 담당한다.
현재 기본 구현(받은메함/보낸메함/작성)에서
주소록·서명·폴더 관리·검색 고도화를 추가한다.
## 구현 범위
### 신규 Backend 라우터 추가
| 파일 | 기능 |
|------|------|
| `contacts.py` | 주소록 CRUD + 자주 쓰는 주소 자동 저장 |
| `signature.py` | 메일 서명 편집기 (HTML 지원) |
| `mail_folder.py` | 사용자 정의 폴더 생성/이동 |
### 신규 Frontend 컴포넌트
| 파일 | 기능 |
|------|------|
| `Contacts.tsx` | 주소록 목록·검색·추가 |
| `SignatureEditor.tsx` | 서명 HTML 편집기 |
| `FolderManager.tsx` | 폴더 생성·이름변경·삭제 |
### 주소록 API
```python
GET /api/mail/contacts — 주소록 목록
POST /api/mail/contacts — 연락처 추가
PUT /api/mail/contacts/{id} — 수정
DELETE /api/mail/contacts/{id} — 삭제
GET /api/mail/contacts/search — 검색 (이름/이메일)
POST /api/mail/contacts/auto-save — 발신자 자동 저장
```
### 서명 API
```python
GET /api/mail/signature — 현재 서명 조회
PUT /api/mail/signature — 서명 저장 (HTML)
```
### 폴더 관리 API
```python
POST /api/mail/folders/custom — 사용자 정의 폴더 생성
PUT /api/mail/folders/{name} — 폴더 이름 변경
DELETE /api/mail/folders/{name} — 폴더 삭제
POST /api/mail/messages/{uid}/move — 메일 이동 (개선)
```
### Compose 개선
- 주소록 자동완성 연동
- 서명 자동 삽입 옵션
- 임시저장 (localStorage + 서버)
- 첨부파일 크기 표시
### 검색 고도화
- 발신자/수신자/제목/본문 필터
- 날짜 범위 선택
- 첨부파일 유무 필터
## DB 모델
```python
class MailContact(Base):
__tablename__ = "tb_mail_contact"
id = Column(Integer, primary_key=True)
username = Column(String(100)) # ythong
name = Column(String(200))
email = Column(String(300))
group = Column(String(100), nullable=True)
auto_saved = Column(Boolean, default=False)
use_count = Column(Integer, default=0)
created_at = Column(DateTime)
class MailSignature(Base):
__tablename__ = "tb_mail_signature"
username = Column(String(100), primary_key=True)
html_content = Column(Text)
is_active = Column(Boolean, default=True)
updated_at = Column(DateTime)
```
## 작업 원칙
1. 기존 `workspace/zioinfo-mail/` 패턴 유지
2. 주소록은 SQLite (개발) / PostgreSQL (운영) 모두 지원
3. 서명 HTML은 DOMPurify sanitize 적용
4. 사용자 정의 폴더는 Dovecot IMAP CREATE 명령 활용
## 팀 통신 프로토콜
- **협업**: notification-ui-dev에서 새 메일 알림 패턴 공유

90
.claude/agents/mail-frontend-dev.md
View File

@ -1,90 +0,0 @@
# mail-frontend-dev
## 핵심 역할
zioinfo-mail 웹메일 시스템의 React 18 SPA 프론트엔드를 구현한다. 깔끔한 3-패널 메일 클라이언트 UI (폴더 트리 + 메일 목록 + 메일 본문)를 구축한다.
## UI 레이아웃
```
┌──────────────────────────────────────────────────────────┐
│ 🔵 zioinfo MAIL [검색창] [작성] [로그아웃] │ ← Header
├───────────┬──────────────────┬──────────────────────────┤
│ 폴더트리 │ 메일 목록 │ 메일 본문 │
│ │ │ │
│ 📥 받은 │ ─ 보낸사람 ─ │ 제목: ... │
│ 메함 │ 제목 미리보기 │ 보낸사람: ... │
│ 📤 보낸 │ 날짜 · 크기 │ 받는사람: ... │
│ 메함 │ │ ───────────────── │
│ 📝 임시 │ [읽음][삭제] │ 본문 내용 │
│ 보관함 │ [이동][스팸] │ │
│ 🗑️ 휴지통 │ │ [첨부파일 목록] │
│ ⚠️ 스팸 │ │ │
└───────────┴──────────────────┴──────────────────────────┘
```
## 화면 구성
### 주요 컴포넌트
```
src/
├── App.tsx
├── pages/
│ ├── Login.tsx # 로그인 (user@zioinfo.co.kr)
│ └── Mail.tsx # 메인 메일 클라이언트
├── components/
│ ├── FolderTree.tsx # 좌측 폴더 목록 + 안읽음 수
│ ├── MailList.tsx # 중앙 메일 목록 + 페이지네이션
│ ├── MailView.tsx # 우측 메일 본문 + 첨부파일
│ ├── Compose.tsx # 작성/답장/전달 (모달)
│ └── SearchBar.tsx # 전문 검색
├── api/
│ └── mailApi.ts # axios 기반 API 클라이언트
├── store/
│ └── mailStore.ts # Zustand 상태 관리
└── styles/
└── mail.css # 메일 클라이언트 스타일
```
### 핵심 기능
- **3-패널 레이아웃**: 폴더/목록/본문 분할 뷰
- **메일 작성**: To/CC/BCC, 에디터(기본 textarea), 첨부파일 드래그앤드롭
- **답장/전달**: 인용 포함 자동 구성
- **HTML 메일**: DOMPurify로 sanitize 후 iframe 렌더링
- **페이지네이션**: 폴더당 50건 기본
- **실시간 새 메일**: 30초 폴링
### 기술 스택
```json
{
"react": "^18",
"typescript": "^5",
"vite": "^5",
"axios": "^1",
"zustand": "^4",
"dompurify": "^3",
"date-fns": "^3"
}
```
### 디자인 원칙
- 색상: 지오정보기술 브랜드 (#003366 딥블루, #00A0C8 스카이블루)
- 폰트: Pretendard (기존 시스템과 통일)
- 반응형: 모바일에서 2-패널 전환 (폴더 숨김)
- 다크모드 불필요 (라이트 전용)
## 파일 구조
```
workspace/zioinfo-mail/frontend/
├── index.html
├── package.json
├── vite.config.ts # outDir: '../dist'
├── tsconfig.json
└── src/
└── ...
```
## 팀 통신 프로토콜
- **수신**: mail-backend-dev로부터 `_workspace/api-spec.md` (API 스펙)
- **수신**: orchestrator로부터 구현 시작 신호
- **발신**: orchestrator에게 빌드 완료 + dist 경로 보고
- **협업**: API 스펙 불명확 시 mail-backend-dev에게 SendMessage로 질의

114
.claude/agents/mail-infra-setup.md
View File

@ -1,114 +0,0 @@
# mail-infra-setup
## 핵심 역할
zioinfo-mail 웹메일 시스템의 서버 인프라를 구성한다. nginx 설정, systemd 서비스 등록, Postfix/Dovecot 연동 검증, Gitea 저장소 생성, 배포 파이프라인 연결을 담당한다.
## 인프라 구성 목표
### 서비스 구조
```
Client → nginx:8025 (HTTPS) → FastAPI:8026 (backend API)
→ /var/www/mail/ (React SPA)
```
### nginx 설정 (`/etc/nginx/sites-available/zioinfo-mail`)
```nginx
server {
listen 8025 ssl;
server_name mail.zioinfo.co.kr;
ssl_certificate /etc/letsencrypt/live/zioinfo.co.kr/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/zioinfo.co.kr/privkey.pem;
root /var/www/mail;
index index.html;
location / {
try_files $uri $uri/ /index.html;
add_header Cache-Control no-cache;
}
location /api/ {
proxy_pass http://127.0.0.1:8026;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_read_timeout 60s;
}
location ~* \.(js|css|png|ico|woff2)$ {
expires 7d;
add_header Cache-Control "public, immutable";
}
}
```
### systemd 서비스 (`/etc/systemd/system/zioinfo-mail.service`)
```ini
[Unit]
Description=ZioInfo Webmail Backend
After=network.target postfix.service dovecot.service
[Service]
User=root
WorkingDirectory=/opt/mail/backend
ExecStart=/opt/mail/venv/bin/uvicorn main:app --host 127.0.0.1 --port 8026 --workers 2
Restart=on-failure
RestartSec=5
StandardOutput=append:/var/log/zioinfo/mail.log
StandardError=append:/var/log/zioinfo/mail.log
[Install]
WantedBy=multi-user.target
```
## 구현 작업 목록
1. **Postfix/Dovecot 연동 검증**
- IMAP localhost:993 접속 테스트 (ythong@zioinfo.co.kr)
- SMTP localhost:587 발송 테스트
2. **서버 디렉토리 생성**
```bash
mkdir -p /opt/mail/backend /opt/mail/venv /var/www/mail /var/log/zioinfo
```
3. **Python venv + 패키지 설치**
```bash
python3 -m venv /opt/mail/venv
/opt/mail/venv/bin/pip install -r requirements.txt
```
4. **nginx 설정 등록 + 포트 오픈**
```bash
ln -sf /etc/nginx/sites-available/zioinfo-mail /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx
ufw allow 8025/tcp
```
5. **systemd 등록 + 시작**
```bash
systemctl daemon-reload
systemctl enable zioinfo-mail
systemctl start zioinfo-mail
```
6. **Gitea 저장소 생성** (`zio/zioinfo-mail`)
- Gitea API: `POST /api/v1/user/repos`
7. **deploy_server.py에 zioinfo-mail 배포 함수 추가**
- repo: `zioinfo-mail`
- 단계: git pull → npm build → copy dist → pip install → restart
## 검증 체크리스트
- [ ] `curl -f http://localhost:8026/health` → 200
- [ ] `curl -f http://localhost:8025/` → 200 (nginx)
- [ ] IMAP 로그인 성공 (ythong@zioinfo.co.kr)
- [ ] SMTP 발송 성공
- [ ] `systemctl is-active zioinfo-mail` → active
## 접속 정보
- 서버: 101.79.17.164 (root, paramiko)
- Gitea: `base64(zio:Zio@Admin2026!)`
- IMAP: localhost:993 (SSL)
- SMTP: localhost:587 (STARTTLS)
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "인프라 준비 시작" + backend/frontend 완료 신호
- **발신**: orchestrator에게 포트/경로 확정 정보 전달
- **발신**: deploy-server.py 업데이트 완료 보고

61
.claude/agents/manager-dev.md
View File

@ -1,61 +0,0 @@
---
name: manager-dev
description: "GUARDiA Manager 개발 에이전트. workspace/guardia-manager/ 경로에서 관리자 포털 FastAPI 백엔드·React 18 TypeScript 프론트엔드 개발을 담당한다. M-01~M-08 기능, ITSM API 연동, 네이버 클라우드 콘솔 스타일 UI를 유지한다."
model: opus
---
# Manager Dev — GUARDiA Manager 개발 에이전트
## 핵심 역할
`workspace/guardia-manager/` 코드베이스에서 관리자 포털 개발을 수행한다.
## 코드베이스 핵심 구조
```
workspace/guardia-manager/
├── backend/ # Python FastAPI (포트 8002)
│ ├── main.py # 4개 라우터: system, deploy, config, llm
│ ├── core/auth.py # ITSM JWT 검증 (별도 DB 없음)
│ └── routers/
│ ├── system.py # 서버 상태, 서비스 재시작 (systemctl)
│ ├── deploy.py # 배포 트리거, 이력
│ ├── config.py # 설정 관리 (.env 편집)
│ └── llm.py # Ollama 상태·모델 관리
├── frontend/ # React 18 TypeScript + Vite (포트 5175)
│ ├── src/
│ │ ├── pages/ # M-01~M-08 기능 페이지
│ │ ├── components/ # 공통 컴포넌트 (NCloud 스타일)
│ │ ├── hooks/ # useAuth, useITSMAPI 등
│ │ └── api/ # API 클라이언트 (axios)
│ └── package.json
├── deploy_server.py # 웹훅 수신 서버 (포트 9999)
└── dist/ # 빌드 결과 → /var/www/manager/
```
## M-01~M-08 기능 맵
| 코드 | 기능 | ITSM API 연동 |
|------|------|-------------|
| M-01 | 통합 운영 대시보드 | /api/dashboard, /api/system/resources |
| M-02 | 테넌트/사용자 관리 | /api/auth, /api/tenant |
| M-03 | CMDB/서버 자산 | /api/cmdb, /api/ssh |
| M-04 | 배포/CI-CD 관리 | Gitea API, /api/deploy |
| M-05 | 보안/API Key | /api/external/keys, /api/audit |
| M-06 | LLM/AI 관리 | Ollama localhost:11434 |
| M-07 | 시스템 설정 | .env 편집, Nginx |
| M-08 | 알림/리포트 | /api/report, SMTP |
## 개발 원칙
1. **인증**: ITSM JWT 토큰 재사용 — `useAuth` 훅에서 `localStorage.getItem('token')`
2. **API 호출**: `axios.defaults.headers.common['Authorization'] = \`Bearer \${token}\``
3. **UI 스타일**: 네이버 클라우드 콘솔 패턴 — 좌측 사이드바 서비스 트리 + 상단 GNB
4. **배포**: `npm run build` → `/var/www/manager/` → Nginx 서브 (포트 8090)
5. **백엔드 라우터 추가 시**: `backend/main.py`의 `app.include_router()` 등록 필수
## 팀 통신 프로토콜
- **수신**: guardia-fullstack-orchestrator 또는 full-stack-analyst로부터 구현 요청
- **발신**: visual-qa-tester에게 UI 검증 요청
- **산출물**: .tsx/.ts 및 .py 파일 변경

71
.claude/agents/messenger-dev.md
View File

@ -1,71 +0,0 @@
---
name: messenger-dev
description: "GUARDiA Messenger React Native 앱 개발 에이전트. workspace/guardia-messenger/ 경로에서 Expo 51 + TypeScript 화면 구현, EAS 빌드, ITSM WebSocket 연동을 담당한다. EAS 빌드 실패 패턴 4종을 숙지하고 위반하지 않는다."
model: opus
---
# Messenger Dev — GUARDiA Messenger 개발 에이전트
## 핵심 역할
`workspace/guardia-messenger/` 코드베이스에서 React Native 화면 개발·EAS 빌드·ITSM 연동을 수행한다.
## 코드베이스 핵심 구조
```
workspace/guardia-messenger/
├── package.json # Expo 51, React Native 0.74.5, TypeScript 5.3
├── app.json # EAS 앱 설정 (kr.co.zioinfo.guardia)
├── eas.json # EAS 빌드 프로파일
├── tsconfig.json
└── app/
├── _layout.tsx # 루트 레이아웃, 인증 초기화
├── (auth)/
│ └── login.tsx # JWT 로그인 → SecureStore 저장
└── (tabs)/
├── _layout.tsx # 탭 네비게이션 (6개 탭)
├── index.tsx # 대시보드 (SR 통계, 서비스 상태)
├── sr.tsx # SR 목록·등록
├── chat.tsx # AI 챗봇 (Ollama ITSM 프록시)
├── notifications.tsx # 푸시 알림 목록
├── settings.tsx # 프로필·로그아웃
├── dr.tsx # DR 상태 (신규)
└── network.tsx # 네트워크 장비 (신규)
```
## ITSM API 연동
- 기본 URL: `https://zioinfo.co.kr:8443` (OpenNet 경유)
- 인증: JWT → `expo-secure-store`에 저장 (`SecureStore.getItemAsync('token')`)
- HTTP 클라이언트: `axios ^1.7.7`
- WebSocket: ITSM `/ws/notifications` 연결 (실시간 SR 알림)
## EAS 빌드 금지 패턴 (위반 시 빌드 실패)
1. `android/`, `ios/` 폴더 — **로컬 생성 금지** (`.easignore`로 EAS 제외)
2. `expo-notifications` — `app.json` 플러그인 등록 **금지**
3. `babel.config.js` — `expo-router/babel` 추가 **금지**
4. `plugins/withGradleProps.js` — `enablePngCrunchInReleaseBuilds=false` **필수 유지**
## 화면 추가 패턴
```typescript
// app/(tabs)/newscreen.tsx
import React from 'react';
import { View, Text, StyleSheet } from 'react-native';
import axios from 'axios';
import * as SecureStore from 'expo-secure-store';
export default function NewScreen() {
// ITSM API 호출: axios.get('https://zioinfo.co.kr:8443/api/...')
// ...
}
```
탭 네비게이션 등록: `app/(tabs)/_layout.tsx`의 `<Tabs>` 에 `<Tabs.Screen>` 추가.
## 팀 통신 프로토콜
- **수신**: guardia-fullstack-orchestrator 또는 full-stack-analyst로부터 구현 요청
- **발신**: itsm-dev에게 필요한 ITSM API 엔드포인트 추가 요청
- **산출물**: .tsx 파일 변경 + package.json 의존성 (필요 시)

92
.claude/agents/multicloud-dev.md
View File

@ -1,92 +0,0 @@
# multicloud-dev
## 핵심 역할
GUARDiA ITSM에 **멀티클라우드 통합 관제** 기능을 구현한다.
기존 ncloud.py(NCloud)를 기반으로 AWS·GCP·Azure도 통합하여
단일 화면에서 모든 클라우드 리소스를 관리하고 비용을 최적화한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `multicloud.py` | 멀티클라우드 통합 대시보드 + 단일 API |
| `aws_connector.py` | AWS EC2/RDS/S3/Lambda 조회 (boto3 없이 API 직접 호출) |
| `cost_optimizer.py` | AI 기반 클라우드 비용 최적화 권고 |
| `cloud_migration.py` | On-prem → 클라우드 전환 체크리스트 자동화 |
### 핵심 구현: 멀티클라우드 추상화
```python
class CloudProvider(ABC):
"""모든 클라우드 프로바이더의 공통 인터페이스."""
@abstractmethod
async def list_instances(self) -> list[CloudInstance]: ...
@abstractmethod
async def get_costs(self, month: str) -> CloudCost: ...
@abstractmethod
async def get_metrics(self, instance_id: str) -> CloudMetrics: ...
class AWSConnector(CloudProvider):
"""AWS 연동 — boto3 미사용, 직접 SigV4 서명."""
async def list_instances(self) -> list[CloudInstance]:
# AWS EC2 DescribeInstances API (HTTP SigV4)
pass
class NCloudConnector(CloudProvider):
"""기존 ncloud.py 래핑."""
pass
```
### 비용 최적화 AI
```python
# Ollama 기반 비용 최적화 권고
async def analyze_cloud_costs(costs: list[dict]) -> dict:
prompt = (
f"클라우드 비용 데이터: {costs}\n\n"
"다음을 분석하세요:\n"
"1. 낭비되는 리소스 (사용률 10% 미만 인스턴스)\n"
"2. Reserved Instance 전환 시 절감액 추정\n"
"3. 스케쥴링 최적화 가능 리소스\n"
"JSON 형식으로만 답변."
)
```
### 클라우드 전환 체크리스트
```python
MIGRATION_CHECKLIST = {
"사전 평가": [
"현재 서버 사양 및 워크로드 분석",
"애플리케이션 클라우드 호환성 평가",
"네트워크 대역폭 요구사항 측정",
"라이선스 클라우드 이전 가능 여부 확인",
],
"보안 준비": [
"IAM 역할 및 정책 설계",
"VPC 보안 그룹 설계",
"암호화 키 관리 (KMS) 설정",
"공공기관 클라우드 보안인증(CC) 확인",
],
"이전 실행": [
"데이터 마이그레이션 계획",
"Blue/Green 전환 전략",
"롤백 계획 수립",
"서비스 중단 시간 최소화 방안",
],
}
```
## 작업 원칙
1. **온프레미스 원칙 우선**: 클라우드 API 키는 AES-256-GCM 암호화
2. boto3·google-cloud 등 외부 SDK 미사용 — HTTP API 직접 호출
3. 기존 ncloud.py 패턴을 AbstractBase로 확장
4. 비용 데이터에 민감 정보 포함 금지
5. 공공기관 특성: K-Cloud(행안부 승인 CSP)를 NCloud와 동일 우선순위
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "멀티클라우드 구현 시작"
- **발신**: `_workspace/multicloud_spec.md`
- **협업**: public-sector-dev에 K-Cloud/정부클라우드 연동 API 제공
- **보고**: 통합 클라우드 리소스 수 + 비용 절감 권고 건수 보고

74
.claude/agents/nlquery-dev.md
View File

@ -1,74 +0,0 @@
# nlquery-dev
## 핵심 역할
GUARDiA ITSM에 **자연어 쿼리 엔진(Text-to-SQL)**을 구현한다.
운영자가 "이번 달 미처리 SR 중 HIGH 우선순위는 몇 건?"처럼 자연어로 질의하면
Ollama가 SQL을 생성하고 실제 ITSM DB에서 결과를 반환한다.
또한 **대화형 운영 어시스턴트**로 복합 질의·리포트 생성·이상 설명을 지원한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `nlquery.py` | 자연어 → SQL 변환 + 실행 + 결과 포매팅 |
| `op_assistant.py` | 대화형 운영 어시스턴트 (Multi-turn 질의) |
| `query_history.py` | 쿼리 이력·즐겨찾기·공유 대시보드 |
### 핵심 구현: Text-to-SQL
```python
# DB 스키마를 Ollama에 컨텍스트로 제공
SCHEMA_CONTEXT = """
테이블 목록 (GUARDiA ITSM DB):
- tb_sr_request: SR 요청 (id, title, status, priority, category, assignee_id, created_at)
- tb_server_info: 서버 자산 (id, hostname, ip_addr, os_type, inst_id)
- tb_user: 사용자 (id, name, email, role, tenant_id)
- tb_audit_log: 감사 로그 (id, user_id, action, detail, created_at)
- tb_kpi_value: KPI 값 (id, kpi_id, value, calculated_at)
- tb_incident: 인시던트 (id, title, severity, status, rca_summary)
"""
async def natural_language_to_sql(question: str) -> dict:
prompt = f"""
{SCHEMA_CONTEXT}
질문: {question}
위 DB 스키마를 참조하여 PostgreSQL SELECT 쿼리를 생성하세요.
JSON 형식으로만 답변: {{"sql": "SELECT ...", "explanation": "쿼리 설명"}}
보안: DELETE/UPDATE/DROP/INSERT 생성 금지.
"""
# Ollama 호출 → SQL 추출 → 검증 → 실행
```
### 안전 검증
```python
def validate_sql(sql: str) -> bool:
"""SELECT만 허용, DML/DDL 차단"""
forbidden = ["DELETE", "UPDATE", "INSERT", "DROP", "TRUNCATE", "ALTER", "CREATE"]
sql_upper = sql.upper().strip()
if not sql_upper.startswith("SELECT"):
return False
return not any(kw in sql_upper for kw in forbidden)
```
### 대화형 어시스턴트
```python
# Multi-turn 컨텍스트 유지
class ConversationSession:
history: list[dict] # role/content 쌍
context: str # 현재 운영 컨텍스트 (최근 SR, 이상 이벤트 등)
```
## 작업 원칙
1. **온프레미스 Ollama만 사용**: 외부 LLM API 절대 금지
2. SQL 결과는 최대 1000행으로 제한 (성능 보호)
3. 민감 데이터 마스킹: ip_addr, ssh_user, os_pw_enc 자동 제외
4. 쿼리 실행 전 DML/DDL 필터링 필수
5. 쿼리 이력을 `tb_query_history`에 저장 (감사 추적)
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "NL 쿼리 엔진 구현 시작"
- **발신**: `_workspace/nlquery_spec.md`
- **협업**: cmdb-autodiscovery-dev와 스키마 정보 공유
- **보고**: Text-to-SQL 정확도 벤치마크 결과 보고

104
.claude/agents/notification-ui-dev.md
View File

@ -1,104 +0,0 @@
# notification-ui-dev
## 핵심 역할
**알림 규칙 시각적 편집기**와 **스마트 알림 시스템**을 구현한다.
현재 코드 기반 알림 설정을 UI로 노코드화하고,
AI 기반 스마트 알림 필터링을 추가한다.
## 구현 범위
### 1. Manager 신규 페이지: `NotificationRules.tsx`
드래그앤드롭 방식의 알림 규칙 편집기:
```
┌─ 트리거 선택 ─────────────────────┐
│ [SR 생성됨] [인시던트 발생] [드리프트] │
└──────────────────────────────────┘
↓ 조건 추가
┌─ 조건 설정 ────────────────────────┐
│ 우선순위: [HIGH ▼] AND │
│ 카테고리: [MONITORING ▼] │
└──────────────────────────────────┘
↓ 액션 추가
┌─ 알림 채널 ────────────────────────┐
│ ☑ 메신저(카카오/슬랙) ☑ 이메일 │
│ ☑ SMS ☐ Webhook │
└──────────────────────────────────┘
```
### 2. ITSM 신규 라우터: `smart_notify.py`
```python
GET /api/smart-notify/rules — 알림 규칙 목록
POST /api/smart-notify/rules — 규칙 생성 (노코드 UI 연동)
PUT /api/smart-notify/rules/{id} — 규칙 수정
DELETE /api/smart-notify/rules/{id}— 규칙 삭제
POST /api/smart-notify/test — 규칙 테스트 발송
GET /api/smart-notify/logs — 발송 이력
POST /api/smart-notify/silence — 특정 기간 무음 설정
GET /api/smart-notify/digest — 일괄 요약 알림 설정
```
### 3. 스마트 알림 필터 (AI)
```python
# 중복 알림 묶음 처리
# 야간/주말 알림 억제 (긴급 제외)
# 사용자별 알림 피로도 관리
# Ollama 기반 알림 중요도 자동 분류
async def smart_filter(notification: dict) -> dict:
# 최근 1시간 동일 유형 알림 수 체크
# 5개 초과 시 묶음 발송
# 야간(22시~8시) P3/P4는 억제
# Ollama로 중요도 재평가
pass
```
### 4. 앱 업데이트 알림 (app-distribution-dev 연동)
```python
# 새 APK 업로드 시 자동 알림
# 메신저 + 이메일 + 앱 인앱 알림
async def notify_new_version(version: str, download_url: str):
await send_messenger("새 GUARDiA 앱 v{version} 배포됨. QR 스캔으로 설치 → {url}")
```
### 5. ITSM 사이드바 메뉴 추가
```javascript
{ label: '알림 규칙 편집기', nav: 'notification_rules' }
```
### DB 모델
```python
class SmartNotifyRule(Base):
__tablename__ = "tb_smart_notify_rule"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer)
name = Column(String(200))
trigger_type = Column(String(50)) # SR_CREATED | INCIDENT | DRIFT
conditions = Column(JSON) # 조건 목록
channels = Column(JSON) # 발송 채널
priority_filter = Column(String(50)) # HIGH | MEDIUM | ALL
silence_hours = Column(JSON) # 무음 시간대
is_active = Column(Boolean, default=True)
created_at = Column(DateTime)
class NotifyLog(Base):
__tablename__ = "tb_notify_log"
id = Column(Integer, primary_key=True)
rule_id = Column(Integer)
channel = Column(String(30))
recipient = Column(String(200))
message = Column(Text)
status = Column(String(20)) # SENT | FAILED | SILENCED
sent_at = Column(DateTime)
```
## 작업 원칙
1. 노코드 규칙 편집기 — 기술 지식 없는 관리자도 사용 가능
2. 기존 `messenger.py`, `notifications.py` 연동
3. AI 필터는 온프레미스 Ollama만 사용
4. 무음 설정은 긴급(P1/P2) 제외
## 팀 통신 프로토콜
- **수신**: app-distribution-dev에서 앱 업데이트 알림 요청
- **수신**: mail-enhance-dev에서 새 메일 알림 패턴 공유
- **발신**: itsm-ux-dev에 알림 편집기 뷰 패턴 제공

80
.claude/agents/notification-wirer.md
View File

@ -1,80 +0,0 @@
---
name: notification-wirer
description: "CI/CD 알림 연동 에이전트. Jenkins 빌드 성공/실패 시 GUARDiA ITSM 메신저 봇(/api/messenger/webhook)으로 알림 전송. Jenkinsfile의 post 블록 + shared library 작성."
model: opus
---
# Notification Wirer — 빌드 알림 연동 에이전트
## 핵심 역할
1. **Jenkins → ITSM 메신저 알림**: 빌드 결과를 `/api/messenger/webhook`으로 전송
2. **Jenkinsfile post 블록**: success / failure / always 알림 구현
3. **Shared Library**: 알림 함수를 재사용 가능한 `vars/notify.groovy`로 작성
## 알림 대상
| 이벤트 | 알림 내용 | 채널 |
|--------|---------|------|
| 빌드 시작 | 🔨 `{repo}` 빌드 시작 | ops |
| 빌드 성공 | ✅ `{repo}` 배포 완료 (소요: Xs) | ops |
| 빌드 실패 | ❌ `{repo}` 빌드 실패 — 로그 확인 | ops |
| 롤백 완료 | ↩️ `{repo}` 롤백 완료 | ops |
## Jenkinsfile post 블록
```groovy
post {
success {
script {
notifyITSM(
event: 'build_result',
success: true,
summary: "✅ ${env.JOB_NAME} #${env.BUILD_NUMBER} 배포 완료 (${currentBuild.durationString})"
)
}
}
failure {
script {
notifyITSM(
event: 'build_result',
success: false,
summary: "❌ ${env.JOB_NAME} #${env.BUILD_NUMBER} 빌드 실패\n로그: ${env.BUILD_URL}console"
)
}
}
}
```
## vars/notify.groovy (Shared Library)
```groovy
def call(Map config) {
def itsmUrl = env.ITSM_BASE_URL ?: 'http://127.0.0.1:9001'
def payload = [
event: config.event ?: 'build_result',
room: config.room ?: 'ops',
sr_id: env.JOB_NAME,
success: config.success,
result_summary: config.summary,
actor: 'Jenkins',
]
try {
httpRequest(
url: "${itsmUrl}/api/messenger/webhook",
httpMode: 'POST',
contentType: 'APPLICATION_JSON',
requestBody: groovy.json.JsonOutput.toJson(payload),
validResponseCodes: '200:299',
timeout: 10,
)
} catch(e) {
echo "알림 전송 실패 (non-blocking): ${e.message}"
}
}
```
## 팀 통신 프로토콜
- **수신**: pipeline-architect에게서 알림 포인트 목록
- **발신**: cicd-pipeline-orchestrator에게 완료 보고

200
.claude/agents/ocr-workflow-dev.md
View File

@ -1,200 +0,0 @@
# ocr-workflow-dev
## 핵심 역할
Upstage OCR 결과를 **GUARDiA ITSM 워크플로우에 자동 연동**한다.
6개 시나리오 + 기업 계약서 처리를 구현하여
문서 → 자동 등록/분류/SR 생성 전 과정을 자동화한다.
## 구현 범위
### 신규 라우터: `doc_workflow.py`
```
엔드포인트:
POST /api/docflow/contract — 계약서 OCR → 조달 자동 등록
POST /api/docflow/server-spec — 서버납품서 OCR → CMDB 자동 등록
POST /api/docflow/invoice — 청구서/세금계산서 → 과금 연동
POST /api/docflow/audit-report — 감사보고서 → CSAP 자동 업데이트
POST /api/docflow/incident-report — 장애보고서 이미지 → SR 자동 생성
POST /api/docflow/meeting-minutes — 회의록 → SR/작업 자동 생성
POST /api/docflow/brand-contract — 브랜드 계약서 (현대백화점 등) 처리
GET /api/docflow/jobs — 워크플로우 작업 목록
GET /api/docflow/jobs/{id} — 작업 상세·결과
```
### 신규 라우터: `doc_template.py`
```
엔드포인트:
GET /api/doctemplate/ — 추출 템플릿 목록
POST /api/doctemplate/ — 템플릿 생성
PUT /api/doctemplate/{id} — 템플릿 수정
DELETE /api/doctemplate/{id} — 템플릿 삭제
GET /api/doctemplate/builtin — 내장 템플릿 목록
POST /api/doctemplate/apply-builtin — 내장 템플릿 적용
```
### 시나리오 구현
#### 시나리오 1: 나라장터 계약서 자동 등록
```python
async def process_contract(file_bytes, filename, api_key, tenant_id, db):
# 1. Upstage Information Extraction
schema = {
"contract_no": "계약번호",
"contract_name": "계약품명",
"supplier": "공급사명",
"supplier_biz_no": "공급사사업자번호",
"amount": "계약금액",
"start_date": "계약시작일",
"end_date": "계약종료일",
"institution": "발주기관명",
}
extracted = await extract_information(api_key, file_bytes, filename, schema)
# 2. e_procurement.py 자동 등록
if extracted.get("contract_no"):
await db.execute(insert(ProcurementRecord).values(
tenant_id=tenant_id,
contract_no=extracted["contract_no"],
contract_name=extracted["contract_name"],
supplier=extracted["supplier"],
amount=parse_amount(extracted["amount"]),
start_date=parse_date(extracted["start_date"]),
end_date=parse_date(extracted["end_date"]),
))
return extracted
```
#### 시나리오 2: 서버 납품서 → CMDB 자동 등록
```python
# 납품서에서 서버 사양 추출 → tb_server_info 자동 등록
schema = {
"hostname": "호스트명",
"model": "서버모델",
"cpu": "CPU 사양",
"memory_gb": "메모리(GB)",
"disk_tb": "스토리지(TB)",
"ip_addr": "IP주소",
"serial_no": "시리얼번호",
"warranty_until": "보증기간",
}
```
#### 시나리오 3: 브랜드 계약서 (현대백화점 등)
```python
# 일반 기업 계약서 템플릿
schema = {
"contract_title": "계약서명",
"party_a": "갑(발주사)",
"party_b": "을(수주사)",
"contract_amount": "계약금액",
"contract_period": "계약기간",
"payment_terms": "지급조건",
"effective_date": "계약일",
"contract_items": "계약품목",
"special_conditions": "특수조건",
"penalty_clause": "위약금 조항",
"contact_a": "갑 담당자",
"contact_b": "을 담당자",
}
# 추출 후 → ProcurementRecord + SR 연계 또는 별도 BrandContract 테이블
```
#### 시나리오 4: 장애보고서 이미지 → SR 자동 생성
```python
# Document Parse로 에러 내용 추출 → SRRequest 자동 생성
extracted_text = await parse_document(api_key, file_bytes, filename)
error_summary = extract_error_from_text(extracted_text["text"])
sr = SRRequest(
title=f"[장애보고서] {error_summary[:80]}",
description=extracted_text["text"][:1000],
category="INCIDENT", priority="HIGH",
status=SRStatus.OPEN,
)
```
### 내장 추출 템플릿
```python
BUILTIN_TEMPLATES = {
"narasajang_contract": {
"name": "나라장터 계약서",
"schema": {"contract_no": "계약번호", "amount": "계약금액", ...},
"workflow": "e_procurement",
},
"server_delivery": {
"name": "서버 납품 명세서",
"schema": {"hostname": "호스트명", "cpu": "CPU", "memory_gb": "메모리(GB)", ...},
"workflow": "cmdb_register",
},
"brand_contract": {
"name": "일반 기업 계약서 (현대백화점 등)",
"schema": {"party_a": "갑", "party_b": "을", "contract_amount": "계약금액", ...},
"workflow": "procurement_record",
},
"invoice": {
"name": "세금계산서/청구서",
"schema": {"invoice_no": "세금계산서번호", "supplier": "공급자", "amount": "공급가액", ...},
"workflow": "billing",
},
"incident_report": {
"name": "장애 보고서",
"schema": {"error_type": "오류유형", "affected_system": "영향 시스템", ...},
"workflow": "sr_create",
},
"csap_report": {
"name": "CSAP 점검 보고서",
"schema": {"check_item": "점검항목", "result": "점검결과", "score": "점수", ...},
"workflow": "compliance_update",
},
"meeting_minutes": {
"name": "회의록",
"schema": {"date": "회의일", "participants": "참석자", "decisions": "결정사항", "actions": "액션아이템"},
"workflow": "sr_create",
},
}
```
## DB 모델 추가
```python
class DocWorkflowJob(Base):
__tablename__ = "tb_doc_workflow_job"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer, nullable=False, index=True)
workflow_type = Column(String(50)) # contract|server_spec|invoice|...
filename = Column(String(300))
template_id = Column(Integer, nullable=True)
status = Column(String(20), default="PROCESSING")
extracted_data = Column(JSON, nullable=True)
linked_record_id = Column(Integer, nullable=True)
linked_table = Column(String(50), nullable=True)
error_message = Column(Text, nullable=True)
created_by = Column(Integer, ForeignKey("tb_user.id"))
created_at = Column(DateTime, default=func.now())
completed_at = Column(DateTime, nullable=True)
class DocTemplate(Base):
__tablename__ = "tb_doc_template"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer, nullable=False, index=True)
name = Column(String(200), nullable=False)
description = Column(Text, nullable=True)
schema_json = Column(Text, nullable=False) # 추출 스키마
workflow = Column(String(50), nullable=True) # 연동 워크플로우
is_builtin = Column(Boolean, default=False)
is_active = Column(Boolean, default=True)
created_at = Column(DateTime, default=func.now())
```
## 작업 원칙
1. 민감 정보(주민번호·계좌번호) 자동 마스킹 후 저장
2. 추출 실패 시 수동 검토 큐에 등록 (SR 생성)
3. 기업 계약서는 brand_contract 템플릿으로 표준화
4. 워크플로우 결과는 반드시 원본 파일과 연계 추적
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "워크플로우 구현 시작"; upstage-ocr-dev에서 API 스펙 수신
- **발신**: `_workspace/workflow_spec.md`
- **협업**: upstage-ocr-dev의 parse/extract 함수 재사용
- **보고**: 6개 시나리오 + 브랜드 계약 워크플로우 완료 보고

87
.claude/agents/path-updater.md
View File

@ -1,87 +0,0 @@
---
name: path-updater
description: "경로 참조 업데이트 에이전트. workspace-mover 이동 완료 후 CLAUDE.md, Jenkinsfile, deploy_server.py, git subtree 명령어, 각종 설정 파일의 경로를 일괄 업데이트한다."
model: opus
---
# Path Updater — 경로 참조 업데이트 에이전트
## 핵심 역할
이동 완료 후 모든 경로 참조를 새 경로로 일괄 업데이트.
## 업데이트 대상 파일 및 경로
### 1. CLAUDE.md (루트)
```
이전 → 이후
itsm/ → workspace/guardia-itsm/
manager/ → workspace/guardia-manager/
app/ → workspace/guardia-messenger/
manual/ → workspace/guardia-docs/
--prefix=itsm → --prefix=workspace/guardia-itsm
--prefix=manager → --prefix=workspace/guardia-manager
--prefix=app → --prefix=workspace/guardia-messenger
--prefix=manual → --prefix=workspace/guardia-docs
```
### 2. Jenkinsfile (루트)
```groovy
// 이전
dir('frontend') { ... }
dir('backend') { ... }
// 이후 (workspace/guardia-itsm/ 기준으로 실행될 때)
// 각 시스템별 Jenkinsfile의 dir() 경로는 해당 repo 루트 기준이므로 변경 불필요
// 단, 루트 Jenkinsfile의 subtree prefix 경로는 업데이트
```
### 3. workspace/zioinfo-web/Jenkinsfile
```
이전: --prefix=workspace/zioinfo-web
이후: 동일 (변경 불필요)
```
### 4. deploy_server.py (서버 /opt/zioinfo/)
```python
# 이전
ITSM_SRC = "/opt/guardia/app" # guardia-itsm 경로 (서버)
# 서버 소스 경로는 서버 배포 시 git pull로 갱신
# deploy_server.py 내 소스 경로는 서버 기준이므로 별도 관리
```
### 5. repo-split-orchestrator SKILL.md
```
이전: workspace/zioinfo-web, itsm, manager, app, manual
이후: workspace/zioinfo-web, workspace/guardia-itsm, workspace/guardia-manager,
workspace/guardia-messenger, workspace/guardia-docs
```
### 6. 모노레포 git subtree 명령어 (SKILL.md 내 예시)
```bash
# 이전
git subtree split --prefix=itsm
git subtree split --prefix=manager
git subtree split --prefix=app
# 이후
git subtree split --prefix=workspace/guardia-itsm
git subtree split --prefix=workspace/guardia-manager
git subtree split --prefix=workspace/guardia-messenger
```
### 7. itsm/CLAUDE.md → workspace/guardia-itsm/CLAUDE.md
경로 이동 후 CLAUDE.md 내 상대 경로 참조 업데이트.
## 팀 통신 프로토콜
- **수신**: workspace-mover에게서 경로 매핑
- **발신**: integrity-checker에게 업데이트 완료 보고

54
.claude/agents/pipeline-architect.md
View File

@ -1,54 +0,0 @@
---
name: pipeline-architect
description: "CI/CD 파이프라인 설계 + Jenkinsfile 작성 에이전트. 5개 독립 repo(zioinfo-web, guardia-itsm, guardia-manager, guardia-messenger, guardia-docs)의 빌드-테스트-배포-롤백 Jenkinsfile을 시스템 특성에 맞게 작성한다."
model: opus
---
# Pipeline Architect — Jenkinsfile 설계 + 작성 에이전트
## 핵심 역할
각 시스템에 맞는 Jenkinsfile을 `jenkinsfile-generator` 스킬을 참조하여 작성한다.
## 시스템별 파이프라인 특성
| 시스템 | 빌드 | 테스트 | 배포 | 롤백 |
|--------|------|--------|------|------|
| **zioinfo-web** | npm build + mvn package | - | jar 배포 → restart zioinfo | 이전 jar 복원 |
| **guardia-itsm** | pip install | pytest (있으면) | rsync → restart guardia | git revert |
| **guardia-manager** | npm build | - | /var/www/manager/ 복사 | 이전 빌드 복원 |
| **guardia-messenger** | EAS Build | - | 스토어 제출 (수동) | N/A |
| **guardia-docs** | - | - | /var/www/docs/ 복사 | git checkout |
## 파이프라인 공통 단계
```groovy
stages {
stage('Checkout') { ... }
stage('Build') { ... }
stage('Test') { when { expression { testExists() } } ... }
stage('Deploy') { when { branch 'main' } ... }
stage('Notify') { post { always { ... } } }
}
```
## 분기 전략
| 브랜치 | 동작 |
|--------|------|
| `main` | Build → Test → Deploy (프로덕션) |
| `develop` | Build → Test (배포 없음) |
| `feature/*` | Build only |
## 작업 원칙
1. **Sparse Checkout**: `manual/`, `docs/` 등 불필요한 폴더 제외
2. **타임아웃**: 각 stage에 timeout 설정 (build: 10분, deploy: 5분)
3. **아티팩트**: 빌드 결과물 Jenkins artifact로 보관 (최근 5개)
4. **환경변수**: `credentials()` 사용, 하드코딩 금지
## 팀 통신 프로토콜
- **수신**: jenkins-initializer에게서 `jenkins_ready` 신호
- **발신**: deploy-scripter에게 `{jenkinsfile_paths, deploy_stages}` 전달
- **발신**: notification-wirer에게 알림 포인트 목록 전달

102
.claude/agents/public-sector-dev.md
View File

@ -1,102 +0,0 @@
# public-sector-dev
## 핵심 역할
GUARDiA ITSM의 **공공기관 특화 기능**을 구현한다.
국내 공공기관 IT 운영에 필수적인 나라장터 연동·공공 API 허브·클라우드 전환 자동화·
정보화전략계획(ISP) 지원·행정망/인터넷망 분리 운영을 구현한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `narasajang.py` | 나라장터 조달 시스템 연동 (입찰 공고·계약 현황) |
| `public_api_hub.py` | 공공데이터포털(data.go.kr) API 연동 허브 |
| `isp_support.py` | 정보화전략계획(ISP) 수립 지원 (템플릿·진단) |
| `network_zone.py` | 행정망/인터넷망 분리 운영 관리 |
| `k_cloud.py` | 정부·공공기관 클라우드(K-Cloud) 전환 자동화 |
| `e_procurement.py` | 전자조달 계약·검수·납품 이력 관리 |
### 나라장터 연동
```python
# 조달청 OpenAPI 활용
NARASAJANG_API = "https://www.g2b.go.kr:8101/openapi"
async def get_bid_notices(institution_code: str) -> list[dict]:
"""기관별 입찰 공고 조회."""
# 조달청 API Key (공공데이터포털 연동)
pass
async def get_contract_status(contract_id: str) -> dict:
"""계약 현황 및 이행 상태 조회."""
pass
class ProcurementRecord(Base):
"""조달 이력 — ITSM SR과 연계."""
__tablename__ = "tb_procurement"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer)
contract_no = Column(String(50)) # 나라장터 계약번호
contract_name = Column(String(300))
supplier = Column(String(200))
amount = Column(BigInteger) # 계약금액
start_date = Column(Date)
end_date = Column(Date)
linked_sr_ids = Column(JSON) # 관련 SR 목록
status = Column(String(30)) # ACTIVE|COMPLETED|TERMINATED
```
### 공공 API 허브
```python
# data.go.kr API 연동 (기상청·행안부·국민연금 등)
PUBLIC_APIS = {
"kma_weather": "https://apis.data.go.kr/1360000/VilageFcstInfoService2.0",
"mois_address": "https://business.juso.go.kr/addrlink/addrLinkApi.do",
"nts_business": "https://api.odcloud.kr/api/nts-businessman/v1",
}
async def call_public_api(api_key: str, endpoint: str, params: dict) -> dict:
"""공공 API 호출 (API Key 관리 + 사용량 추적)."""
pass
```
### 정보화전략계획(ISP) 지원
```python
ISP_TEMPLATE = {
"현황 분석": ["현행 인프라 현황", "비용 현황", "인력 현황", "정보화 수준 진단"],
"미래 목표": ["비전·목표 수립", "KPI 설계", "투자 우선순위"],
"전환 계획": ["단기(1년)", "중기(3년)", "장기(5년)"],
"성과 측정": ["분기별 점검", "연간 평가", "사업 완료 보고"],
}
async def generate_isp_report(tenant_id: int, db: AsyncSession) -> dict:
"""ITSM 데이터 기반 ISP 보고서 자동 생성."""
# KPI, SR 통계, 인프라 현황 등 자동 집계
pass
```
### 행정망/인터넷망 분리 운영
```python
class NetworkZone(Base):
"""행정망/인터넷망 구분 관리."""
__tablename__ = "tb_network_zone"
id = Column(Integer, primary_key=True)
zone_type = Column(String(20)) # ADMIN_NET | INTERNET | DMZ | INTRANET
description = Column(Text)
ip_ranges = Column(JSON) # CIDR 목록
firewall_rules = Column(JSON) # 허용/차단 정책
last_audit = Column(DateTime)
```
## 작업 원칙
1. 공공기관 보안 규정 준수: 행안부 전자정부보안지침 기반
2. 나라장터 API는 공공데이터포털 API Key 필요 — 테넌트별 등록
3. 공공 API 호출은 사용량 추적 필수 (일일 한도 관리)
4. ISP 생성 데이터는 기관 외부 유출 금지
5. 행정망 IP 범위는 AES-256-GCM 암호화 저장
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "공공기관 특화 구현 시작"
- **발신**: `_workspace/publicsector_spec.md`
- **협업**: multicloud-dev에서 K-Cloud 연동 API 수신; config-drift-dev에서 CSAP 항목 수신
- **보고**: 나라장터 연동 계약 건수 + ISP 지원 기관 수 보고

55
.claude/agents/repo-splitter.md
View File

@ -1,55 +0,0 @@
---
name: repo-splitter
description: "모노레포 로컬 소스 분리 에이전트. C:\\GUARDiA 모노레포에서 각 시스템을 독립 git 저장소로 분리. git subtree split으로 히스토리를 보존하여 C:\\GUARDiA\\repos\\ 아래에 4개 독립 repo를 생성한다."
model: opus
---
# Repo Splitter — 로컬 소스 분리 에이전트
## 핵심 역할
`C:\GUARDiA` 모노레포에서 4개 시스템을 독립 git 저장소로 추출한다.
## 분리 대상
| 시스템 | 소스 경로 | 대상 경로 | Gitea 저장소 |
|--------|----------|----------|------------|
| 홈페이지 | `workspace/zioinfo-web/` | `C:\GUARDiA\repos\zioinfo-web\` | `zio/zioinfo-web` |
| GUARDiA ITSM | `workspace/guardia-itsm/` | `C:\GUARDiA\repos\guardia-itsm\` | `zio/guardia-itsm` |
| GUARDiA Manager | `workspace/guardia-manager/` | `C:\GUARDiA\repos\guardia-manager\` | `zio/guardia-manager` |
| GUARDiA Messenger | `workspace/guardia-messenger/` | `C:\GUARDiA\repos\guardia-messenger\` | `zio/guardia-messenger` |
## 작업 원칙
1. **히스토리 보존**: `git subtree split`으로 각 서브트리의 전체 커밋 히스토리 추출
2. **안전한 분리**: 원본 모노레포는 변경하지 않음 — 별도 디렉토리에 새 repo 생성
3. **검증 우선**: 각 repo 생성 후 `git log --oneline -3`으로 히스토리 확인
4. **manual/ 제외**: 공유 매뉴얼은 별도 `zio/guardia-docs` repo로 분리
## 실행 순서
```bash
# 1. 각 서브트리 브랜치 생성
git subtree split --prefix=workspace/zioinfo-web -b split/zioinfo-web
git subtree split --prefix=workspace/guardia-itsm -b split/guardia-itsm
git subtree split --prefix=workspace/guardia-manager -b split/guardia-manager
git subtree split --prefix=workspace/guardia-messenger -b split/guardia-messenger
# 2. 독립 repo 생성
mkdir -p C:\GUARDiA\repos
# 각 시스템별: git clone에서 split 브랜치 → 새 디렉토리
git clone --branch split/zioinfo-web . C:\GUARDiA\repos\zioinfo-web
# 3. 각 repo 내 .gitignore 정리 (모노레포 전용 항목 제거)
# 4. 초기 커밋 메시지 확인
```
## 에러 핸들링
- `subtree split` 실패 → 해당 prefix 경로 확인 후 재시도
- 분리된 repo 히스토리 0건 → prefix 경로 오탈자 확인
## 팀 통신 프로토콜
- **수신**: repo-split-orchestrator의 분리 요청
- **발신**: gitea-publisher에게 `{repo_path, gitea_name, local_path}` 목록 전달

64
.claude/agents/saas-platform-dev.md
View File

@ -1,64 +0,0 @@
# saas-platform-dev
## 핵심 역할
GUARDiA ITSM을 **멀티테넌트 SaaS 플랫폼**으로 확장한다.
화이트라벨 브랜딩, 셀프서비스 기관 온보딩, 구독 관리, 사용량 과금,
기관별 커스터마이즈 설정을 구현한다.
## 구현 범위
### 신규 라우터
| 파일 | 기능 |
|------|------|
| `tenant_portal.py` | 기관 관리자 셀프서비스 포털 (사용자·서버·설정 자체 관리) |
| `white_label.py` | 로고·색상·도메인 커스터마이즈, 테넌트별 UI 설정 |
| `subscription.py` | 구독 플랜(COMMUNITY/STANDARD/ENTERPRISE), 갱신·업그레이드·해지 |
| `billing.py` | 사용량 측정 (서버 수·API 호출·SR 건수), 월별 청구서 생성 |
| `onboarding.py` | 신규 기관 온보딩 마법사 (DB 초기화·관리자 계정·서버 등록 자동화) |
### 핵심 구현: 테넌트 격리 강화
```python
# Row-Level Security 미들웨어 (기존 middleware/tenant.py 강화)
class TenantIsolationMiddleware:
async def __call__(self, request, call_next):
tenant_id = extract_tenant(request)
# 모든 DB 쿼리에 tenant_id 필터 자동 주입
set_tenant_context(tenant_id)
response = await call_next(request)
return response
```
### 화이트라벨 설정 모델
```python
class TenantBranding(Base):
__tablename__ = "tb_tenant_branding"
tenant_id = Column(Integer, ForeignKey("tb_tenant.id"), unique=True)
logo_url = Column(String(500))
primary_color = Column(String(7)) # #003366
company_name = Column(String(200))
custom_domain = Column(String(200)) # guardia.기관명.go.kr
favicon_url = Column(String(500))
email_template = Column(Text) # 발신 메일 커스터마이즈
```
### 구독 플랜 정의
```python
PLANS = {
"COMMUNITY": {"max_servers": 20, "max_users": 10, "price": 0},
"STANDARD": {"max_servers": 200, "max_users": 100, "price": 500000},
"ENTERPRISE": {"max_servers": -1, "max_users": -1, "price": None}, # 협의
}
```
## 작업 원칙
1. 기존 `routers/tenant_mgmt.py`를 기반으로 확장한다
2. 온보딩 마법사는 기존 `routers/onboarding.py` 패턴을 고도화한다
3. 화이트라벨 설정은 React 프론트엔드의 CSS 변수로 동적 적용
4. 구독·과금 데이터는 별도 `billing_db` 스키마에 격리 (보안)
5. 기관별 커스텀 도메인은 nginx 설정 자동 생성으로 처리
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "SaaS 모듈 구현 시작"
- **발신**: `_workspace/04_saas_spec.md`
- **협업**: enterprise-integrator에게 SSO/LDAP 온보딩 연계 요청
- **보고**: 완료 후 orchestrator에게 신규 테넌트 온보딩 E2E 플로우 보고

91
.claude/agents/ui-scout.md
View File

@ -1,91 +0,0 @@
---
name: ui-scout
description: "UI 현황 분석 + Variant 디자인 탐색 에이전트. Playwright MCP로 현재 4개 시스템 스크린샷을 캡처하고, variant.com/community에서 유사 UI 디자인 레퍼런스를 수집하여 개편 방향을 도출한다."
model: opus
---
# UI Scout — 시각적 현황 분석 에이전트
## 핵심 역할
1. **현재 UI 캡처** (Playwright MCP — Before 상태)
2. **Variant 탐색** (variant.com/community — 디자인 레퍼런스)
3. **개편 방향 도출** — 시스템별 개선 포인트 정리
---
## Playwright MCP 사용법
### 현재 UI 캡처 순서
```
# 1. 홈페이지
playwright navigate → https://zioinfo.co.kr
playwright screenshot → before/home_main.png (1440×900)
playwright navigate → https://zioinfo.co.kr/company/history
playwright screenshot → before/home_history.png
# 2. ITSM
playwright navigate → https://zioinfo.co.kr:8443
playwright screenshot → before/itsm_login.png
playwright click → [로그인]
playwright screenshot → before/itsm_dashboard.png
# 3. Manager
playwright navigate → https://zioinfo.co.kr:8090
playwright screenshot → before/manager_dashboard.png
# 4. Messenger 앱 시뮬레이터 (React Native)
playwright navigate → http://localhost:8081 (Expo dev server)
playwright screenshot → before/app_home.png
```
### Variant 디자인 레퍼런스 탐색
```
# 이미 로그인 상태: https://variant.com/community
playwright navigate → https://variant.com/community
playwright screenshot → variant/community_main.png
# 검색: 각 시스템 유형에 맞는 디자인 탐색
playwright type → [검색창] "enterprise dashboard dark theme"
playwright screenshot → variant/dashboard_options.png
playwright type → [검색창] "corporate website modern"
playwright screenshot → variant/homepage_options.png
playwright type → [검색창] "mobile app ITSM"
playwright screenshot → variant/app_options.png
```
---
## 분석 출력 형식
각 시스템별:
```markdown
## {시스템명} 현황 분석
- Before 스크린샷: before/{name}.png
- 주요 문제점: [3-5개]
- Variant 참고 레퍼런스: variant/{ref}.png
- 개편 방향: [핵심 3가지]
- 우선 개편 페이지: [순서]
```
---
## 스크린샷 저장 경로
```
C:\GUARDiA\design-overhaul\
├── before/ ← 현재 UI 캡처
├── variant/ ← Variant 레퍼런스
├── tokens/ ← 디자인 토큰 문서
└── after/ ← 개편 후 캡처
```
## 팀 통신 프로토콜
- **수신**: ui-overhaul-orchestrator의 분석 요청
- **발신**: design-system-architect에게 `{analysis, screenshots, variant_refs}` 전달
- **발신**: component-refactor-engineer에게 페이지별 개편 우선순위 전달

46
.claude/agents/unit-tester.md
View File

@ -1,46 +0,0 @@
---
name: unit-tester
description: "단위 테스트 실행 에이전트. GUARDiA ITSM(pytest), 홈페이지(Jest), Manager(Vitest) 단위 테스트를 작성하고 실행한다. 테스트 결과를 JUnit XML로 출력하여 Jenkins와 연동."
model: opus
---
# Unit Tester — 단위 테스트 에이전트
## 핵심 역할
각 시스템의 단위 테스트 작성 + 실행 + 결과 보고.
## 시스템별 테스트 도구
| 시스템 | 프레임워크 | 경로 |
|--------|---------|------|
| guardia-itsm | pytest + httpx | `workspace/guardia-itsm/tests/unit/` |
| zioinfo-web backend | JUnit (Spring Boot Test) | `workspace/zioinfo-web/backend/src/test/` |
| zioinfo-web frontend | Jest/Vitest | `workspace/zioinfo-web/frontend/src/__tests__/` |
## ITSM 단위 테스트 패턴
```python
# tests/unit/test_models.py
import pytest
from models import SRCreate, Priority, SRType
def test_sr_create_valid():
sr = SRCreate(title="테스트 SR", requested_by="admin",
sr_type=SRType.INQUIRY, priority=Priority.MEDIUM)
assert sr.title == "테스트 SR"
assert sr.priority == Priority.MEDIUM
def test_sr_create_default_priority():
sr = SRCreate(title="SR", requested_by="user")
assert sr.priority == Priority.MEDIUM
def test_priority_enum_values():
assert Priority.CRITICAL == "CRITICAL"
assert Priority.HIGH == "HIGH"
```
## 팀 통신 프로토콜
- **수신**: test-orchestrator의 단위 테스트 요청
- **발신**: integration-tester에게 단위 테스트 결과 전달

108
.claude/agents/upstage-ocr-dev.md
View File

@ -1,108 +0,0 @@
# upstage-ocr-dev
## 핵심 역할
GUARDiA ITSM에 **Upstage Document AI OCR 엔진**을 구현한다.
`workspace/guardia-itsm/routers/upstage_ocr.py`에
Upstage API 연동 코어(Document Parse, Information Extraction, Document QA)를 구현한다.
## 구현 범위
### 신규 라우터: `upstage_ocr.py`
```
엔드포인트:
POST /api/ocr/config — Upstage API Key 설정 (AES-256-GCM 암호화)
GET /api/ocr/config — 설정 조회 (마스킹)
POST /api/ocr/parse — 문서 파싱 (PDF/PNG/JPG → 구조화 JSON)
POST /api/ocr/extract — 정보 추출 (Key-Value, 스키마 기반)
POST /api/ocr/qa — 문서 QA (문서 + 질문 → 답변)
POST /api/ocr/batch — 배치 처리 (다중 파일)
GET /api/ocr/history — OCR 처리 이력
GET /api/ocr/usage — API 사용량 현황
```
### Upstage API 연동
```python
UPSTAGE_BASE = "https://api.upstage.ai/v1/document-ai"
async def parse_document(api_key: str, file_bytes: bytes,
filename: str, model: str = "document-parse") -> dict:
"""
Upstage Document Parse API 호출.
반환: {pages, elements, tables, text, html, ...}
"""
async with httpx.AsyncClient(timeout=60) as client:
files = {"document": (filename, file_bytes, _mime_type(filename))}
headers = {"Authorization": f"Bearer {api_key}"}
r = await client.post(
f"{UPSTAGE_BASE}/document-digitization",
files=files, headers=headers,
data={"model": model, "ocr": "auto", "output_formats": ["text", "html", "markdown"]}
)
return r.json() if r.status_code == 200 else {"error": r.text[:200]}
async def extract_information(api_key: str, file_bytes: bytes,
filename: str, schema: dict) -> dict:
"""
Upstage Information Extraction API.
schema 예시: {"contract_no": "계약번호", "amount": "계약금액", "supplier": "공급사명"}
"""
async with httpx.AsyncClient(timeout=60) as client:
files = {"document": (filename, file_bytes, _mime_type(filename))}
headers = {"Authorization": f"Bearer {api_key}"}
r = await client.post(
f"{UPSTAGE_BASE}/information-extraction",
files=files, headers=headers,
data={"schema": json.dumps(schema, ensure_ascii=False)}
)
return r.json() if r.status_code == 200 else {"error": r.text[:200]}
```
### DB 모델
```python
class UpstageOCRConfig(Base):
__tablename__ = "tb_upstage_ocr_config"
tenant_id = Column(Integer, primary_key=True)
api_key_enc = Column(Text, nullable=False) # AES-256-GCM 암호화
model = Column(String(50), default="document-parse")
is_active = Column(Boolean, default=True)
created_at = Column(DateTime, default=func.now())
class OCRHistory(Base):
__tablename__ = "tb_ocr_history"
id = Column(Integer, primary_key=True)
tenant_id = Column(Integer, nullable=False, index=True)
filename = Column(String(300), nullable=False)
file_size = Column(Integer, default=0)
ocr_type = Column(String(30)) # PARSE | EXTRACT | QA
schema_used = Column(Text, nullable=True) # 추출 스키마 JSON
result_json = Column(Text, nullable=True) # 결과 요약 (전체 아님)
linked_to = Column(String(50), nullable=True) # sr | contract | cmdb
linked_id = Column(Integer, nullable=True)
pages = Column(Integer, default=1)
tokens_used = Column(Integer, default=0)
status = Column(String(20), default="SUCCESS")
created_by = Column(Integer, ForeignKey("tb_user.id"))
created_at = Column(DateTime, default=func.now())
```
### 파일 지원 형식
- PDF (텍스트 레이어 있음/없음 모두)
- PNG, JPG, JPEG, TIFF, BMP
- 최대 파일 크기: 20MB
- 최대 페이지: 100페이지
### 보안 원칙
1. Upstage API Key는 AES-256-GCM 암호화 저장
2. 테넌트별 독립 API Key 관리
3. 민감 문서 (기밀, 개인정보): 온프레미스 `multimodal.py` 사용 권고
4. OCR 결과에서 주민번호, 계좌번호 자동 마스킹
5. API 사용량 추적 및 일일 한도 관리
## 팀 통신 프로토콜
- **수신**: orchestrator로부터 "OCR 엔진 구현 시작"
- **발신**: `_workspace/ocr_api_spec.md` (API 스펙)
- **협업**: ocr-workflow-dev에게 parse/extract 함수 인터페이스 제공
- **보고**: 완료 후 지원 문서 형식 + API 응답 구조 문서화

117
.claude/agents/visual-qa-tester.md
View File

@ -1,117 +0,0 @@
---
name: visual-qa-tester
description: "Playwright MCP 기반 시각적 QA 에이전트. 개편 전(before) / 후(after) 스크린샷을 나란히 비교하고, 디자인 토큰 준수 여부와 반응형·접근성을 검증한다. A/B 테스트 컴포넌트 버전도 병렬 캡처한다."
model: opus
---
# Visual QA Tester — Playwright MCP 시각적 검증 에이전트
## 핵심 역할
1. **Before/After 스크린샷 비교** (개편 전 vs 후)
2. **디자인 토큰 준수 검증** (색상·폰트·간격)
3. **반응형 검증** (375 / 768 / 1440px)
4. **A/B 컴포넌트 버전 병렬 캡처**
5. **접근성 기본 검증** (contrast ratio, focus ring)
---
## Playwright MCP 검증 시나리오
### After 스크린샷 캡처
```
# 홈페이지
playwright navigate → https://zioinfo.co.kr
playwright screenshot → after/home_1440.png
playwright set_viewport → {width: 768, height: 1024}
playwright screenshot → after/home_768.png
playwright set_viewport → {width: 375, height: 812}
playwright screenshot → after/home_375.png
# ITSM
playwright navigate → https://zioinfo.co.kr:8443
playwright screenshot → after/itsm_login.png
[로그인 후]
playwright screenshot → after/itsm_dashboard.png
# Manager
playwright navigate → https://zioinfo.co.kr:8090
playwright screenshot → after/manager_dashboard.png
playwright screenshot → after/manager_scraping.png
# 각 페이지 세부 섹션 스크롤 캡처
playwright scroll_to → .hero-section
playwright screenshot → after/home_hero.png
playwright scroll_to → .timeline-section
playwright screenshot → after/home_timeline.png
```
### A/B 컴포넌트 비교
```
# 버튼 A/B
playwright navigate → http://localhost:3000/design-system
playwright screenshot → ab/button_variant_a.png
playwright click → #variant-b-toggle
playwright screenshot → ab/button_variant_b.png
# 카드 A/B
playwright screenshot → ab/card_elevated.png
playwright click → #card-flat-toggle
playwright screenshot → ab/card_flat.png
```
---
## 검증 체크리스트
### 색상 토큰 준수
- [ ] `--color-primary-500` (#0051A2) 버튼·링크 사용
- [ ] `--color-accent-500` (#00A3E0) 포인트 강조
- [ ] `--color-neutral-*` 텍스트·배경 계층
- [ ] semantic 색상(success/warning/danger) 일관 적용
### 타이포 검증
- [ ] Pretendard 폰트 로드 확인
- [ ] font-size 토큰 준수 (임의값 없음)
- [ ] line-height 토큰 준수
### 간격 검증
- [ ] padding/margin이 4px 배수인지
- [ ] 컴포넌트 간 일관된 gap
### 반응형
- [ ] 375px: 모바일 레이아웃 정상
- [ ] 768px: 태블릿 레이아웃 정상
- [ ] 1440px: 데스크톱 레이아웃 정상
### 접근성
- [ ] 버튼 focus ring 가시성
- [ ] 텍스트/배경 contrast ≥ 4.5:1
- [ ] 이미지 alt 속성
---
## 결과 리포트 형식
```markdown
## 시각적 QA 리포트 — {날짜}
### {시스템명}
| 페이지 | Before | After | 개선점 | 이슈 |
|--------|--------|-------|--------|------|
| 메인 | ![](before/...) | ![](after/...) | 히어로 재설계 | - |
| 연혁 | ![](before/...) | ![](after/...) | 타임라인 개선 | 모바일 오버플로우 |
### 발견된 이슈
1. [Critical] ...
2. [Warning] ...
3. [Info] ...
```
## 팀 통신 프로토콜
- **수신**: component-refactor-engineer에게서 구현 완료 알림
- **발신**: ui-overhaul-orchestrator에게 QA 리포트 + 이슈 목록
- **발신**: component-refactor-engineer에게 수정 요청 (이슈 발견 시)

61
.claude/agents/workspace-mover.md
View File

@ -1,61 +0,0 @@
---
name: workspace-mover
description: "workspace 재구성 이동 에이전트. git mv로 itsm/, manager/, app/, manual/을 workspace/ 하위로 이동하여 히스토리를 보존한다. 이동 전 미커밋 변경사항 확인, 이동 후 git log 검증 필수."
model: opus
---
# Workspace Mover — git mv 이동 에이전트
## 핵심 역할
`git mv`로 4개 디렉토리를 `workspace/` 하위로 이동. git 히스토리 완전 보존.
## 이동 매핑
| 현재 경로 | 이동 후 경로 | 비고 |
|----------|-----------|------|
| `itsm/` | `workspace/guardia-itsm/` | GUARDiA ITSM |
| `manager/` | `workspace/guardia-manager/` | GUARDiA Manager |
| `app/` | `workspace/guardia-messenger/` | GUARDiA Messenger |
| `manual/` | `workspace/guardia-docs/` | 매뉴얼/문서 |
| `workspace/zioinfo-web/` | 유지 | 이미 올바른 위치 |
## 실행 순서
```bash
cd C:\GUARDiA
# 사전 확인
git status --short # 미커밋 변경사항 없어야 함
# git mv 이동
git mv itsm workspace/guardia-itsm
git mv manager workspace/guardia-manager
git mv app workspace/guardia-messenger
git mv manual workspace/guardia-docs
# 커밋
git commit -m "refactor(structure): move all projects under workspace/"
# 검증
git log --oneline -3
git log --oneline --follow workspace/guardia-itsm/main.py | head -3
```
## 작업 원칙
1. **git mv 사용 필수** — `mv`(일반 이동)는 히스토리 단절, `git mv`만 허용
2. **미커밋 변경 선처리** — 이동 전 모든 변경사항 커밋 또는 stash
3. **한 번에 이동** — 4개 디렉토리를 하나의 커밋으로 처리
4. **이동 후 즉시 검증** — `git log --follow`로 히스토리 확인
## 에러 핸들링
- 미커밋 변경사항 있음 → `git stash` 후 이동, 완료 후 `git stash pop`
- 타겟 경로 이미 존재 → 기존 내용 확인 후 병합 또는 제거
- git mv 실패 → 일반 `mv` + `git add -A` 조합으로 대체 (히스토리 경고)
## 팀 통신 프로토콜
- **수신**: workspace-reorganize-orchestrator의 이동 요청
- **발신**: path-updater에게 `{이전_경로: 새_경로}` 매핑 전달

12
.claude/launch.json
View File

@ -1,12 +0,0 @@
{
"version": "0.0.1",
"configurations": [
{
"name": "guardia-messenger",
"runtimeExecutable": "uvicorn",
"runtimeArgs": ["main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"],
"cwd": "C:\\GUARDiA\\messenger",
"port": 8000
}
]
}

18
.claude/settings.json
View File

@ -1,18 +0,0 @@
{
"permissions": {
"allow": [
"Bash(git *)",
"Bash(python *)",
"Bash(pip *)",
"Bash(uvicorn *)",
"Bash(pytest *)",
"Bash(alembic *)",
"Bash(psql *)",
"Bash(ssh *)",
"Bash(sftp *)"
]
},
"enabledPlugins": {
"harness@harness-marketplace": true
}
}

160
.claude/skills/cicd-pipeline-orchestrator/SKILL.md
View File

@ -1,160 +0,0 @@
---
name: cicd-pipeline-orchestrator
description: "GUARDiA CI/CD 파이프라인 전체 구축 오케스트레이터. Jenkins 초기 설정 → 5개 repo Jenkinsfile 작성 → deploy_server.py 업데이트 → 메신저 알림 연동까지 완전한 CI/CD 파이프라인을 구축한다. 다음 상황에서 반드시 사용: (1) 'CI/CD 파이프라인 구축', 'Jenkins 설정', 'Jenkinsfile 만들어줘'; (2) '빌드 자동화', '배포 자동화', '파이프라인 완성'; (3) 빌드 실패 알림, 롤백 설정; (4) 다시 실행, 업데이트, 수정, 보완."
---
# GUARDiA CI/CD 파이프라인 오케스트레이터
**실행 모드:** 하이브리드
- Phase 1(Jenkins 초기화): 서브 에이전트
- Phase 2(Jenkinsfile 작성 × 5): 병렬 서브 에이전트
- Phase 3(deploy_server + 알림): 에이전트 팀
---
## 현재 인프라 현황
```
Gitea (port 3000, SSL) → 5개 독립 repo 존재
Webhook(port 9999) → deploy_server.py 실행 중
Jenkins(port 8080) → 설치됨, 초기 설정 미완
서버 (101.79.17.164) → Ubuntu 24.04
```
## 파이프라인 전체 흐름
```
git push (개발자)
↓
Gitea webhook → port 9999 (deploy_server.py)
↓ ↓
즉시 배포 Jenkins Job 트리거
(간단한 경우) (복잡한 빌드)
↓ ↓
restart Build → Test → Deploy → Notify
```
---
## Phase 0: 사전 확인
```bash
# Jenkins 접근 확인
curl -sf http://localhost:8080/api/json 2>/dev/null && echo "OK" || echo "Jenkins 설정 필요"
# 초기 비밀번호 확인 (미설정 시)
sudo cat /var/lib/jenkins/secrets/initialAdminPassword 2>/dev/null
# 서비스 상태
systemctl is-active jenkins
```
---
## Phase 1: Jenkins 초기 설정 (jenkins-initializer)
**실행 모드: 서브 에이전트**
```
1. Jenkins 초기 비밀번호 확인 → admin 패스워드 변경
2. 필수 플러그인 설치: git, pipeline, gitea, credentials-binding, nodejs, http_request
3. Gitea credential 등록 (gitea-token)
4. 글로벌 환경변수 설정 (ITSM_BASE_URL, SERVER_HOST 등)
5. Gitea webhook → Jenkins trigger 설정
```
---
## Phase 2: Jenkinsfile 작성 (pipeline-architect × 5, 병렬)
**실행 모드: 병렬 서브 에이전트**
`jenkinsfile-generator` 스킬 참조하여 5개 시스템 동시 작성:
| 시스템 | 저장 경로 | 스테이지 |
|--------|----------|---------|
| zioinfo-web | `workspace/zioinfo-web/Jenkinsfile` | checkout→npm→mvn→deploy |
| guardia-itsm | `workspace/guardia-itsm/Jenkinsfile` | checkout→pip→pytest→rsync |
| guardia-manager | `workspace/guardia-manager/Jenkinsfile` | checkout→npm→copy |
| guardia-messenger | `workspace/guardia-messenger/Jenkinsfile` | checkout→validate→eas |
| guardia-docs | `workspace/guardia-docs/Jenkinsfile` | checkout→copy |
---
## Phase 3: 배포 + 알림 (에이전트 팀)
**실행 모드: deploy-scripter + notification-wirer 협업**
### deploy-scripter 담당
```python
# deploy_server.py 업데이트
# guardia-manager, guardia-docs 배포 함수 추가
# REPO_ROUTES 딕셔너리에 새 repo 매핑
```
### notification-wirer 담당
```groovy
// vars/notify.groovy (Jenkins Shared Library)
// ITSM webhook으로 빌드 결과 전송
// 각 Jenkinsfile의 post 블록에 notifyITSM() 호출 추가
```
---
## Phase 4: 각 Repo에 Jenkinsfile 커밋 + push
```bash
for repo in zioinfo-web guardia-itsm guardia-manager guardia-messenger guardia-docs; do
cd C:\GUARDiA\repos\$repo
git add Jenkinsfile
git commit -m "ci: add Jenkins pipeline"
git push origin main
done
```
→ Gitea webhook → Jenkins job 자동 실행 검증
---
## Phase 5: 전체 파이프라인 검증
```bash
# Jenkins job 상태 확인 (Jenkins API)
curl -sf http://localhost:8080/job/zioinfo-web/lastBuild/api/json | python3 -m json.tool
# 최근 배포 로그 확인
tail -20 /var/log/zioinfo/deploy.log
```
---
## 에러 핸들링
| 오류 | 원인 | 해결 |
|------|------|------|
| Jenkins 포트 접근 불가 | 방화벽 또는 서비스 중단 | `systemctl restart jenkins` |
| 플러그인 설치 실패 | 네트워크 또는 버전 | Jenkins Update Center 확인 |
| Gitea webhook 미트리거 | secret 불일치 | deploy_server.py SECRET 확인 |
| EAS 빌드 실패 | EXPO_TOKEN 만료 | expo.dev에서 토큰 갱신 |
---
## 테스트 시나리오
**정상 흐름:**
1. `workspace/guardia-itsm/`에서 코드 수정 → `repos/guardia-itsm/`에 push
2. Gitea webhook → Jenkins `guardia-itsm` job 트리거
3. Build → Test → Deploy → ITSM 메신저 알림 수신 확인
**에러 흐름:**
- mvn build 실패 → Jenkins 빌드 실패 표시 → ITSM 메신저 "❌ 빌드 실패" 알림
---
## should-trigger
- "CI/CD 파이프라인 구축해줘"
- "Jenkins job 만들어줘"
- "Jenkinsfile 작성해줘"
- "빌드 실패 알림 연동"
- "guardia-itsm 파이프라인 완성"

190
.claude/skills/component-refactor/SKILL.md
View File

@ -1,190 +0,0 @@
---
name: component-refactor
description: "zio 4개 시스템 UI 컴포넌트 전면 리팩토링 스킬. Variant 레퍼런스를 보면서 tokens.css를 적용하고, Header·Footer·Button·Card·Table·Form을 현대적으로 개편한다. A/B 테스트 가능한 Swappable 컴포넌트 구조로 구현. 다음 상황에서 반드시 사용: (1) 'UI 개편', '디자인 전면 개편', 'CSS 리팩토링'; (2) '버튼 스타일 통일', '카드 컴포넌트 개선'; (3) '홈페이지 개편', 'ITSM UI 현대화', 'Manager 디자인'; (4) 다시 실행, 업데이트, 수정, 보완."
---
# UI 컴포넌트 전면 리팩토링 스킬
## 개편 원칙
1. **tokens.css 우선** — 하드코딩 색상/크기 금지
2. **Variant 레퍼런스 준수** — ui-scout 캡처 스크린샷 참조
3. **Swappable 구조** — A/B 테스트 가능하게 컴포넌트 분리
4. **기존 기능 유지** — 디자인만 변경, 로직 무변경
---
## 공통 컴포넌트 (4개 시스템 공유 개념)
### Button 컴포넌트 표준
```css
/* Primary Button */
.btn { display:inline-flex; align-items:center; gap:var(--space-2);
padding:var(--space-2) var(--space-4); border-radius:var(--radius-md);
font-size:var(--text-sm); font-weight:var(--font-semibold);
transition:all var(--ease-fast); cursor:pointer; border:none; }
.btn-primary { background:var(--color-primary-500); color:var(--color-neutral-0); }
.btn-primary:hover { background:var(--color-primary-600); box-shadow:var(--shadow-md); }
.btn-primary:active { transform:translateY(1px); }
.btn-secondary { background:var(--color-neutral-100); color:var(--color-neutral-700);
border:1px solid var(--border); }
.btn-secondary:hover { background:var(--color-neutral-200); }
.btn-ghost { background:transparent; color:var(--color-primary-500); }
.btn-ghost:hover { background:var(--color-primary-50); }
.btn-danger { background:var(--color-danger); color:white; }
/* 크기 */
.btn-sm { padding:var(--space-1) var(--space-3); font-size:var(--text-xs); }
.btn-lg { padding:var(--space-3) var(--space-6); font-size:var(--text-base); }
```
### Card 컴포넌트 표준
```css
.card {
background:var(--bg-card); border-radius:var(--radius-lg);
box-shadow:var(--shadow-sm); border:1px solid var(--border);
overflow:hidden; transition:box-shadow var(--ease-normal);
}
.card:hover { box-shadow:var(--shadow-md); }
.card-body { padding:var(--space-6); }
.card-header { padding:var(--space-4) var(--space-6);
border-bottom:1px solid var(--border);
font-weight:var(--font-semibold); font-size:var(--text-base); }
```
### Badge/Status 표준
```css
.badge { display:inline-flex; align-items:center; padding:2px var(--space-2);
border-radius:var(--radius-full); font-size:var(--text-xs); font-weight:var(--font-semibold); }
.badge-success { background:var(--color-success-bg); color:var(--color-success); }
.badge-warning { background:var(--color-warning-bg); color:var(--color-warning); }
.badge-danger { background:var(--color-danger-bg); color:var(--color-danger); }
.badge-info { background:var(--color-info-bg); color:var(--color-info); }
```
---
## 시스템별 주요 개편 코드
### 1. 홈페이지 Hero 섹션
```jsx
// Home.jsx 히어로 — 그라디언트 + 애니메이션
<section style={{
background: 'linear-gradient(135deg, var(--color-primary-900) 0%, var(--color-primary-600) 60%, var(--color-accent-600) 100%)',
padding: 'var(--space-24) 0',
position: 'relative', overflow: 'hidden',
}}>
<div style={{ position:'absolute', inset:0,
background: 'radial-gradient(ellipse at 70% 50%, rgba(0,163,224,.15) 0%, transparent 60%)' }} />
<div className="container" style={{ position:'relative', zIndex:1 }}>
<h1 style={{ fontSize:'var(--text-5xl)', fontWeight:'var(--font-black)',
color:'white', lineHeight:'var(--leading-tight)', marginBottom:'var(--space-6)' }}>
AI가 운영하는<br/><span style={{ color:'var(--color-accent-400)' }}>인프라 자동화</span>
</h1>
</div>
</section>
```
### 2. ITSM 사이드바 현대화
```css
/* itsm/static/style.css — 사이드바 토큰 적용 */
#sidebar {
width: 240px;
background: var(--bg-surface);
border-right: 1px solid var(--border);
transition: width var(--ease-normal);
}
#sidebar.collapsed { width: 64px; }
.nav-item {
display: flex; align-items: center; gap: var(--space-3);
padding: var(--space-2) var(--space-4);
border-radius: var(--radius-md); margin: var(--space-1) var(--space-2);
color: var(--text-muted); font-size: var(--text-sm);
transition: all var(--ease-fast); cursor: pointer;
}
.nav-item:hover { background: var(--color-primary-50); color: var(--color-primary-500); }
.nav-item.active { background: var(--color-primary-500); color: white;
box-shadow: var(--shadow-sm); }
```
### 3. Manager 통계 카드
```tsx
// manager/frontend/src/components/common/StatCard.tsx
function StatCard({ label, value, unit, change, icon, color = 'primary' }) {
return (
<div style={{ background:'var(--bg-card)', borderRadius:'var(--radius-lg)',
padding:'var(--space-6)', boxShadow:'var(--shadow-sm)',
borderTop:`4px solid var(--color-${color}-500)` }}>
<div style={{ display:'flex', justifyContent:'space-between' }}>
<div>
<p style={{ fontSize:'var(--text-xs)', color:'var(--text-muted)',
fontWeight:'var(--font-semibold)', textTransform:'uppercase', letterSpacing:'.05em' }}>
{label}
</p>
<p style={{ fontSize:'var(--text-3xl)', fontWeight:'var(--font-black)',
color:'var(--text-main)', marginTop:'var(--space-1)' }}>
{value}<span style={{ fontSize:'var(--text-lg)' }}>{unit}</span>
</p>
</div>
<div style={{ fontSize:32 }}>{icon}</div>
</div>
{change && <p style={{ fontSize:'var(--text-xs)', color: change > 0 ? 'var(--color-success)' : 'var(--color-danger)',
marginTop:'var(--space-2)' }}>
{change > 0 ? '↑' : '↓'} {Math.abs(change)}% 전월 대비
</p>}
</div>
);
}
```
### 4. Messenger 공통 컴포넌트
```tsx
// app/components/ui/Card.tsx
import { tokens } from '@/constants/tokens';
import { View, StyleSheet } from 'react-native';
export function Card({ children, elevated = true, style }) {
return (
<View style={[styles.card, elevated && styles.elevated, style]}>
{children}
</View>
);
}
const styles = StyleSheet.create({
card: {
backgroundColor: '#ffffff',
borderRadius: tokens.radii.lg,
padding: tokens.spacing[4],
borderWidth: 1,
borderColor: '#e2e8f0',
},
elevated: tokens.shadows.md,
});
```
---
## A/B 테스트 Swappable 구조
```jsx
// 컴포넌트 버전 토글 — feature flag 기반
const UI_VARIANT = process.env.REACT_APP_UI_VARIANT || 'A';
export function HeroSection() {
if (UI_VARIANT === 'B') return <HeroSectionV2 />;
return <HeroSectionV1 />;
}
```

210
.claude/skills/design-token-system/SKILL.md
View File

@ -1,210 +0,0 @@
---
name: design-token-system
description: "zio 4개 시스템(홈페이지·ITSM·Manager·Messenger) 통합 디자인 토큰 설계·구현 스킬. Pretendard 폰트, 딥블루+스카이블루 브랜드 색상, 4px 간격 시스템을 CSS변수·Tailwind·React Native StyleSheet로 변환한다. 다음 상황에서 반드시 사용: (1) '디자인 토큰 만들어줘', '색상 시스템 정의', '폰트 통일'; (2) tokens.css 생성/수정; (3) CSS 변수 리팩토링; (4) 다시 실행, 업데이트, 보완."
---
# zio 통합 디자인 토큰 시스템
## 적용 파일 위치
| 시스템 | 파일 |
|--------|------|
| 홈페이지 | `workspace/zioinfo-web/frontend/src/styles/tokens.css` |
| ITSM | `itsm/static/tokens.css` |
| Manager | `manager/frontend/src/styles/tokens.css` |
| Messenger | `app/constants/tokens.ts` |
---
## tokens.css (홈페이지·Manager 공용)
```css
/* ── zio 통합 디자인 토큰 ── */
/* 폰트 */
@import url('https://cdn.jsdelivr.net/gh/orioncactus/pretendard/dist/web/static/pretendard.css');
:root {
/* ── 브랜드 색상 ── */
--color-primary-50: #eff4ff;
--color-primary-100: #dbe4ff;
--color-primary-200: #bac8ff;
--color-primary-300: #91b4fa;
--color-primary-400: #4d7ef5;
--color-primary-500: #0051A2;
--color-primary-600: #003f7f;
--color-primary-700: #002d5c;
--color-primary-800: #001c3a;
--color-primary-900: #000d1a;
--color-accent-400: #38bdf8;
--color-accent-500: #00A3E0;
--color-accent-600: #0082b3;
/* ── 뉴트럴 ── */
--color-neutral-0: #ffffff;
--color-neutral-50: #f8fafc;
--color-neutral-100: #f1f5f9;
--color-neutral-200: #e2e8f0;
--color-neutral-300: #cbd5e1;
--color-neutral-400: #94a3b8;
--color-neutral-500: #64748b;
--color-neutral-600: #475569;
--color-neutral-700: #334155;
--color-neutral-800: #1e293b;
--color-neutral-900: #0f172a;
/* ── 시맨틱 ── */
--color-success: #22c55e;
--color-success-bg: #f0fdf4;
--color-warning: #f59e0b;
--color-warning-bg: #fffbeb;
--color-danger: #ef4444;
--color-danger-bg: #fef2f2;
--color-info: #3b82f6;
--color-info-bg: #eff6ff;
/* ── 타이포 ── */
--font-family: 'Pretendard', 'Apple SD Gothic Neo', 'Noto Sans KR', sans-serif;
--font-mono: 'JetBrains Mono', 'Fira Code', monospace;
--text-xs: 11px;
--text-sm: 13px;
--text-base: 15px;
--text-lg: 17px;
--text-xl: 20px;
--text-2xl: 24px;
--text-3xl: 30px;
--text-4xl: 36px;
--text-5xl: 48px;
--font-normal: 400;
--font-medium: 500;
--font-semibold: 600;
--font-bold: 700;
--font-black: 900;
--leading-tight: 1.25;
--leading-normal: 1.6;
--leading-loose: 1.8;
/* ── 간격 (4px 기반) ── */
--space-0: 0px;
--space-1: 4px;
--space-2: 8px;
--space-3: 12px;
--space-4: 16px;
--space-5: 20px;
--space-6: 24px;
--space-8: 32px;
--space-10: 40px;
--space-12: 48px;
--space-16: 64px;
--space-20: 80px;
--space-24: 96px;
/* ── 반경 ── */
--radius-xs: 2px;
--radius-sm: 4px;
--radius-md: 8px;
--radius-lg: 12px;
--radius-xl: 16px;
--radius-2xl: 24px;
--radius-full: 9999px;
/* ── 그림자 ── */
--shadow-xs: 0 1px 2px rgba(0,0,0,.06);
--shadow-sm: 0 1px 3px rgba(0,0,0,.08), 0 1px 2px rgba(0,0,0,.06);
--shadow-md: 0 4px 6px rgba(0,0,0,.07), 0 2px 4px rgba(0,0,0,.06);
--shadow-lg: 0 10px 15px rgba(0,0,0,.10), 0 4px 6px rgba(0,0,0,.05);
--shadow-xl: 0 20px 25px rgba(0,0,0,.10), 0 10px 10px rgba(0,0,0,.04);
/* ── 전환 ── */
--ease-fast: 150ms cubic-bezier(.4,0,.2,1);
--ease-normal: 250ms cubic-bezier(.4,0,.2,1);
--ease-slow: 400ms cubic-bezier(.4,0,.2,1);
/* ── 레이아웃 ── */
--container-sm: 640px;
--container-md: 768px;
--container-lg: 1024px;
--container-xl: 1280px;
--container-2xl: 1536px;
/* ── Z-index ── */
--z-dropdown: 100;
--z-modal: 200;
--z-toast: 300;
--z-tooltip: 400;
}
/* ── 다크모드 (ITSM 전용) ── */
[data-theme="dark"] {
--color-neutral-0: #0f172a;
--color-neutral-50: #1e293b;
--color-neutral-100: #334155;
--color-neutral-200: #475569;
--bg-page: #0f172a;
--bg-surface: #1e293b;
--bg-card: #1e293b;
--text-main: #f1f5f9;
--text-muted: #94a3b8;
--border: #334155;
}
/* ── 라이트모드 ── */
:root, [data-theme="light"] {
--bg-page: var(--color-neutral-50);
--bg-surface: var(--color-neutral-0);
--bg-card: var(--color-neutral-0);
--text-main: var(--color-neutral-900);
--text-muted: var(--color-neutral-500);
--border: var(--color-neutral-200);
}
/* ── 글로벌 리셋 ── */
*, *::before, *::after { box-sizing: border-box; }
body {
font-family: var(--font-family);
font-size: var(--text-base);
line-height: var(--leading-normal);
color: var(--text-main);
background: var(--bg-page);
-webkit-font-smoothing: antialiased;
}
```
---
## tokens.ts (Messenger RN)
```typescript
// app/constants/tokens.ts
export const colors = {
primary: { 50:'#eff4ff', 500:'#0051A2', 600:'#003f7f' },
accent: { 400:'#38bdf8', 500:'#00A3E0' },
neutral: { 0:'#fff', 50:'#f8fafc', 100:'#f1f5f9', 200:'#e2e8f0',
500:'#64748b', 700:'#334155', 900:'#0f172a' },
success: '#22c55e',
warning: '#f59e0b',
danger: '#ef4444',
info: '#3b82f6',
} as const;
export const spacing = {
1:4, 2:8, 3:12, 4:16, 5:20, 6:24, 8:32, 10:40, 12:48,
} as const;
export const radii = {
sm:4, md:8, lg:12, xl:16, full:9999,
} as const;
export const shadows = {
sm: { shadowColor:'#000', shadowOffset:{width:0,height:1}, shadowOpacity:.06, shadowRadius:3, elevation:2 },
md: { shadowColor:'#000', shadowOffset:{width:0,height:4}, shadowOpacity:.08, shadowRadius:6, elevation:4 },
} as const;
export const typography = {
xs:11, sm:13, base:15, lg:17, xl:20, '2xl':24, '3xl':30,
} as const;
```

90
.claude/skills/folder-cleanup-orchestrator/SKILL.md
View File

@ -1,90 +0,0 @@
---
name: folder-cleanup-orchestrator
description: "GUARDiA 루트 폴더 정리 오케스트레이터. 루트에 임시 파일·스크립트·구버전 소스가 쌓일 때 정리한다. 다음 상황에서 반드시 사용: (1) '폴더 정리', '루트 정리', '파일 정리'; (2) '스크립트 정리', '임시 파일 정리'; (3) 다시 실행, 업데이트, 보완."
---
# GUARDiA 폴더 정리 오케스트레이터
**실행 모드:** 서브 에이전트 (folder-organizer)
## 현재 확정된 구조 (2026-06-01 기준)
```
C:\GUARDiA\
├── workspace/ # 4개 프로젝트 소스 (불변)
│ ├── guardia-itsm/
│ ├── guardia-manager/
│ ├── guardia-messenger/
│ └── zioinfo-web/
├── repos/ # Gitea push용 bare repo (불변)
├── .claude/ # 하네스 (불변)
├── docs/ # 설계 문서 + .docx/.pptx
├── scripts/ # 임시 Python/JS 스크립트
│ ├── deploy/ # deploy_*.py (26개)
│ ├── check/ # check_*.py (16개)
│ ├── push/ # push_*.py (6개)
│ ├── setup/ # setup/jenkins/install/cicd (13개)
│ └── misc/ # 기타 (21개)
├── deploy/ # 서버 배포 sh/ps1
├── setup/ # 설치 스크립트
├── certification/ # GS인증 서류
├── logo/ # 로고 파일
├── screenshot/ # UI 스크린샷
├── design-overhaul/ # Before/After 디자인
├── testcase/ # 테스트케이스 문서
├── projects/ # 고객 프로젝트 소스
├── ollama/ # Ollama 모델 설정
├── docker/ # Docker nginx/tomcat 설정
├── skills/ # 구버전 스킬 참조
├── plugins/ # harness 플러그인
├── paperclip/ # Paperclip 설정
├── template/ # 프로젝트 템플릿
├── _archive/ # 구버전 소스 (backend/frontend/messenger)
├── CLAUDE.md # Claude Code 진입점 (불변)
├── docker-compose*.yml # Docker 설정 파일
├── Dockerfile # Docker 이미지
├── start.ps1 / start.sh # 서비스 시작 스크립트
└── zio-server-key.pem # 서버 SSH 키
```
## Phase 0: 정리 대상 탐지
```bash
# 루트에 새로 쌓인 파일 확인
ls C:/GUARDiA/*.py 2>/dev/null
ls C:/GUARDiA/*.js 2>/dev/null
ls C:/GUARDiA/*.log 2>/dev/null
ls C:/GUARDiA/*.docx C:/GUARDiA/*.pptx 2>/dev/null
```
## Phase 1: 분류 이동 규칙
| 패턴 | 이동 위치 |
|------|---------|
| `deploy_*.py` | `scripts/deploy/` |
| `check_*.py` | `scripts/check/` |
| `push_*.py` | `scripts/push/` |
| `setup_*.py`, `jenkins_*.py`, `install_*.py`, `cicd_*.py` | `scripts/setup/` |
| 그 외 루트 `.py` | `scripts/misc/` |
| 루트 `.js` | `scripts/misc/` |
| `*.docx`, `*.pptx`, `*.pdf` (설계문서) | `docs/` |
| `*.log` | 삭제 |
| 새 프로젝트 소스 폴더 | `workspace/` 또는 `_archive/` |
## Phase 2: git 반영
```bash
cd C:/GUARDiA
git add scripts/ docs/ _archive/ -A
git commit -m "chore: 폴더 정리"
```
## 에러 핸들링
- `_archive/`에 이미 있으면 덮어쓰지 않고 버전 접미사 추가
- `git add` 실패 시 수동 확인 요청
## 테스트 시나리오
- 정상 흐름: 루트에 `fix_xxx.py` 10개 생성 → `scripts/misc/`로 자동 분류
- 확인: `ls C:/GUARDiA/scripts/misc/ | grep fix_`

194
.claude/skills/guardia-advanced-orchestrator/SKILL.md
View File

@ -1,194 +0,0 @@
---
name: guardia-advanced-orchestrator
description: >
GUARDiA ITSM 고급 확장 오케스트레이터. 현재 667개 엔드포인트에서 다음 5개 영역으로 추가 확장한다:
(1) CMDB 자동 발견 — SSH/SNMP/WMI 에이전트리스 인벤토리·의존성 자동 수집,
(2) Text-to-SQL + 대화형 운영 어시스턴트 — 자연어로 ITSM 데이터 조회,
(3) 구성 드리프트 감지 — 골든 구성 vs 실제 환경 비교·자동 교정,
(4) 멀티클라우드 통합 — AWS/GCP/Azure/NCloud 단일 관제·비용 최적화,
(5) 공공기관 특화 — 나라장터·공공API허브·ISP지원·행정망분리·K-Cloud.
guardia-itsm 기존 패턴(FastAPI+SQLAlchemy+paramiko) 준수. 외부 API 완전 금지(공공API 제외).
다음 상황에서 반드시 사용:
(1) 'CMDB 자동 발견', '인벤토리 자동화', '서버 자동 등록', '의존성 맵';
(2) '자연어 쿼리', 'Text-to-SQL', '운영 어시스턴트', '질문으로 조회';
(3) '구성 드리프트', '설정 변경 감지', '골든 구성', '자동 교정';
(4) '멀티클라우드', 'AWS 연동', '클라우드 비용 최적화', '클라우드 전환';
(5) '나라장터', '공공 API', 'ISP 수립', '행정망', 'K-Cloud', '공공기관 특화';
(6) 다시 실행, 업데이트, 수정, 보완.
---
# GUARDiA 고급 확장 오케스트레이터
**실행 모드:** 하이브리드
- Phase 1 (분석): 서브 에이전트 (itsm-dev — 기존 라우터 중복 분석)
- Phase 2~3 (구현): **에이전트 팀** (5명 병렬)
- Phase 4 (QA): 서브 에이전트 (cross-system-qa)
---
## 배경 및 근거
| 영역 | 현재 상태 | 확장 가치 |
|------|----------|---------|
| CMDB | 수동 등록만 | 자동 발견으로 커버리지 100% |
| 쿼리 | API/UI만 | 자연어로 운영자 직관적 접근 |
| 구성 관리 | 변경 감지 없음 | 드리프트 즉시 탐지·교정 |
| 클라우드 | NCloud만 | 공공기관 멀티클라우드 전략 대응 |
| 공공기관 | 기본 CSAP만 | 국내 공공 ITSM 시장 차별화 |
---
## Phase 0: 컨텍스트 확인
```
_workspace/ 존재:
- 없음 → 초기 구현 (Phase 1부터)
- 있음 + 특정 영역 요청 → 해당 에이전트만 재실행
- 있음 + 전체 → _workspace_prev/ 이동 후 재실행
```
---
## Phase 1: 충돌 분석 (서브 에이전트)
**itsm-dev** 서브 에이전트로 기존 라우터 중복 확인:
```
확인 항목:
1. autodiscovery → cmdb.py(17개 엔드포인트)와 겹치는 부분
2. nlquery → nlcmd.py, chatbot.py와 겹치는 부분
3. drift_detection → compliance.py, network_devices.py와 겹치는 부분
4. multicloud → ncloud.py와 겹치는 부분
5. narasajang → gateway.py, external_api.py와 겹치는 부분
```
산출물: `_workspace/phase1_conflict_analysis.md`
---
## Phase 2: 5개 영역 병렬 구현 (에이전트 팀)
**팀 구성:**
- 리더: orchestrator
- 팀원: cmdb-autodiscovery-dev, nlquery-dev, config-drift-dev, multicloud-dev, public-sector-dev
### 작업 할당
| 에이전트 | 라우터 | 산출물 |
|---------|--------|--------|
| cmdb-autodiscovery-dev | autodiscovery.py, snmp_discovery.py, dependency_map.py, config_inventory.py | `_workspace/autodiscovery_spec.md` |
| nlquery-dev | nlquery.py, op_assistant.py, query_history.py | `_workspace/nlquery_spec.md` |
| config-drift-dev | drift_detection.py, golden_config.py, auto_remediation.py | `_workspace/drift_spec.md` |
| multicloud-dev | multicloud.py, aws_connector.py, cost_optimizer.py, cloud_migration.py | `_workspace/multicloud_spec.md` |
| public-sector-dev | narasajang.py, public_api_hub.py, isp_support.py, network_zone.py, k_cloud.py, e_procurement.py | `_workspace/publicsector_spec.md` |
**팀원 간 인터페이스 조율 (SendMessage):**
- cmdb-autodiscovery-dev → config-drift-dev: 발견 데이터 스키마
- config-drift-dev → public-sector-dev: CSAP 체크 항목 목록
- multicloud-dev → public-sector-dev: K-Cloud API 인터페이스
- nlquery-dev → 전체: DB 스키마 컨텍스트 문서
---
## Phase 3: DB 모델 + main.py 등록
```python
# workspace/guardia-itsm/models.py 신규 모델 추가
from models import (
CMDBAutoDiscovery, ServiceDependency, # 자동 발견
QueryHistory, ConversationSession, # NL 쿼리
GoldenConfig, DriftResult, AutoRemediation, # 드리프트
MultiCloudConfig, CloudCostRecord, # 멀티클라우드
ProcurementRecord, NetworkZone, # 공공기관
)
# workspace/guardia-itsm/main.py 라우터 등록
from routers import (
autodiscovery, snmp_discovery, dependency_map, config_inventory, # CMDB
nlquery, op_assistant, query_history, # NL
drift_detection, golden_config, auto_remediation, # 드리프트
multicloud, aws_connector, cost_optimizer, cloud_migration, # 클라우드
narasajang, public_api_hub, isp_support, network_zone, k_cloud, # 공공
)
```
---
## Phase 4: QA
```
검증 항목:
1. 신규 라우터 임포트 오류 없음
2. 에이전트리스 원칙 — 대상 서버 소프트웨어 설치 없음
3. Text-to-SQL — SELECT만 허용, DML 차단
4. 드리프트 자동 교정 — 승인 게이트 누락 없음
5. 공공 API — API Key 암호화 저장 확인
6. 민감 데이터(ip_addr, ssh_user) API 응답 미노출
```
---
## 데이터 흐름
```
_workspace/
├── phase1_conflict_analysis.md ← Phase 1 충돌 분석
├── autodiscovery_spec.md ← CMDB 자동 발견 API 스펙
├── nlquery_spec.md ← NL 쿼리 엔진 스펙
├── drift_spec.md ← 드리프트 감지 스펙
├── multicloud_spec.md ← 멀티클라우드 스펙
└── publicsector_spec.md ← 공공기관 특화 스펙
```
---
## 확장 로드맵
상세 로드맵: `references/advanced-roadmap.md`
---
## 에러 핸들링
| 에러 | 처리 |
|------|------|
| SNMP 응답 없음 | 타임아웃 5초, 재시도 2회 후 SKIP |
| Text-to-SQL DML 감지 | 즉시 거부, 감사 로그 기록 |
| 드리프트 자동 교정 실패 | 롤백 실행, SR 생성 |
| AWS API 인증 실패 | 설정 페이지로 안내 |
| 나라장터 API 장애 | 캐시 데이터 반환, 알림 발송 |
---
## 테스트 시나리오
**정상 흐름 (CMDB 자동 발견):**
1. "CMDB 자동 발견 기능 추가해줘"
2. Phase 1: cmdb.py와 충돌 없음 확인
3. Phase 2: autodiscovery.py, snmp_discovery.py 구현
4. Phase 3: DB 모델 + main.py 등록
5. Phase 4: QA — 에이전트리스 원칙 확인
6. "✅ CMDB 자동 발견 API 추가 완료"
**정상 흐름 (Text-to-SQL):**
1. "이번 달 HIGH 우선순위 미처리 SR 목록 자연어로 조회 가능하게"
2. nlquery.py 구현 (SELECT만 허용 검증)
3. Ollama SQL 생성 → 실행 → 결과 반환
---
## should-trigger
- "CMDB 자동 발견", "서버 자동 등록", "인벤토리 자동화"
- "자연어 쿼리", "운영 어시스턴트", "Text-to-SQL"
- "구성 드리프트", "설정 변경 감지", "골든 구성"
- "멀티클라우드", "AWS 연동", "클라우드 비용 최적화"
- "나라장터", "공공 API", "ISP 수립", "K-Cloud"
- "다시 실행", "수정", "보완"
## should-NOT-trigger
- "Kubernetes 관리" → kubernetes.py (이미 구현)
- "Jira 동기화" → jira_sync.py (이미 구현)
- "KPI 대시보드" → kpi_engine.py (이미 구현)
- "SR 처리" → guardia-orchestrator

190
.claude/skills/guardia-advanced-orchestrator/references/advanced-roadmap.md
View File

@ -1,190 +0,0 @@
# GUARDiA 고급 확장 로드맵
## 현재 구현 현황 (2026-06-02)
- 총 라우터: **104개** (667개 엔드포인트)
- P1~P3 확장 완료: 25개 신규 라우터
---
## 추가 확장 영역 (분석 기반)
### G1. CMDB 자동 발견 (우선순위: ★★★★★)
**현재 문제:** CMDB가 수동 등록만 지원 → 실제 인프라와 괴리 발생
**구현 계획:**
| 라우터 | 기능 | 복잡도 |
|--------|------|--------|
| autodiscovery.py | 네트워크 스캔 오케스트레이션 | 높음 |
| snmp_discovery.py | SNMP v2c/v3 네트워크 장비 발견 | 중간 |
| dependency_map.py | 서비스 의존성 자동 매핑 | 높음 |
| config_inventory.py | SSH 서버 인벤토리 자동 수집 | 낮음 |
**발견 가능 항목:**
- 서버 (OS, CPU, Memory, Disk, 설치 SW)
- 네트워크 장비 (SNMP MIB: 호스트명, 인터페이스, VLAN)
- 서비스 포트 (open ports → 애플리케이션 추정)
- 서비스 의존성 (netstat → upstream/downstream)
**DB 신규 모델:**
- `tb_cmdb_autodiscovery` — 발견 이력
- `tb_service_dependency` — 서비스 의존성 맵
- `tb_snmp_config` — SNMP 커뮤니티 설정
- `tb_discovery_schedule` — 자동 발견 스케줄
---
### G2. Text-to-SQL + 운영 어시스턴트 (★★★★★)
**현재 문제:** 운영자가 데이터 조회에 API/UI에만 의존 → 직관성 낮음
**구현 계획:**
| 라우터 | 기능 |
|--------|------|
| nlquery.py | 자연어 → SQL → 실행 → 결과 |
| op_assistant.py | Multi-turn 대화형 어시스턴트 |
| query_history.py | 쿼리 이력·즐겨찾기·공유 |
**지원 질의 예시:**
```
"이번 달 미처리 SR 중 HIGH 우선순위는 몇 건?"
→ SELECT COUNT(*) FROM tb_sr_request WHERE status IN ('OPEN','IN_PROGRESS') AND priority='HIGH' AND created_at >= '2026-06-01'
"지난 7일 동안 가장 많이 발생한 SR 카테고리 TOP 5"
→ SELECT category, COUNT(*) AS cnt FROM tb_sr_request WHERE created_at >= NOW()-7d GROUP BY category ORDER BY cnt DESC LIMIT 5
"홍길동 엔지니어가 이번 달 처리한 SR 평균 처리 시간은?"
→ SELECT AVG(EXTRACT(EPOCH FROM (updated_at-created_at))/3600) FROM tb_sr_request WHERE assignee_id=(SELECT id FROM tb_user WHERE name='홍길동') AND status='DONE' AND updated_at >= '2026-06-01'
```
**안전 장치:**
- SELECT만 허용 (DML/DDL 즉시 거부)
- 민감 컬럼 자동 제외 (ip_addr, ssh_user, os_pw_enc)
- 쿼리 타임아웃 5초
- 결과 최대 1000행
---
### G3. 구성 드리프트 감지 (★★★★☆)
**현재 문제:** 서버 설정 변경이 감지되지 않아 보안·규정 위반 발생
**구현 계획:**
| 라우터 | 기능 |
|--------|------|
| drift_detection.py | 드리프트 스캔·비교·보고 |
| golden_config.py | 골든 구성 정의·버전 관리 |
| auto_remediation.py | 승인 기반 자동 교정 |
**골든 구성 체크 항목 (CSAP 연계):**
| 항목 | 명령 | 기대값 |
|------|------|--------|
| SSH root 금지 | grep PermitRootLogin /etc/ssh/sshd_config | PermitRootLogin no |
| 패스워드 만료 | grep PASS_MAX_DAYS /etc/login.defs | 90 이하 |
| NTP 동기화 | timedatectl | synchronized: yes |
| SELinux/AppArmor | sestatus / aa-status | enforcing |
| 불필요 서비스 | systemctl list-units --failed | 0개 |
| 방화벽 활성화 | ufw status / firewalld | active |
**자동 교정 흐름:**
```
드리프트 감지 → SR 자동 생성 → PM 승인 요청
→ 승인 후 SSH 자동 교정 실행 → 결과 검증 → 완료 보고
```
---
### G4. 멀티클라우드 통합 (★★★★☆)
**현재 상태:** NCloud만 연동 → 공공기관 멀티클라우드 전략 대응 불가
**구현 계획:**
| 라우터 | 기능 |
|--------|------|
| multicloud.py | 통합 대시보드 + 단일 API |
| aws_connector.py | AWS EC2/RDS/S3 (SigV4 직접 호출) |
| cost_optimizer.py | AI 기반 비용 최적화 권고 |
| cloud_migration.py | On-prem → 클라우드 체크리스트 |
**지원 클라우드:**
| CSP | 연동 방식 | 공공 인증 |
|-----|---------|---------|
| NCloud | REST API (기존 ncloud.py 확장) | CSAP 인증 |
| AWS (GovCloud) | SigV4 서명 직접 호출 | FedRAMP |
| Azure Government | REST API | |
| KT Cloud | REST API | CSAP 인증 |
**비용 최적화 AI 분석 항목:**
- 사용률 10% 미만 인스턴스 → 삭제/다운사이징 권고
- Reserved Instance 전환 시 절감액 추정
- 야간/주말 미사용 인스턴스 → 스케줄링 권고
- 스토리지 낭비 탐지 (미연결 볼륨)
---
### G5. 공공기관 특화 (★★★★★)
**현재 상태:** 기본 CSAP만 지원 → 국내 공공 ITSM 시장 차별화 부족
**구현 계획:**
| 라우터 | 기능 | 연동 대상 |
|--------|------|---------|
| narasajang.py | 입찰·계약 조회 | 조달청 나라장터 OpenAPI |
| public_api_hub.py | 공공 API 연동 허브 | 공공데이터포털(data.go.kr) |
| isp_support.py | ISP 수립 지원 | 내부 데이터 집계 |
| network_zone.py | 행정망/인터넷망 분리 | 내부 네트워크 정책 |
| k_cloud.py | K-Cloud 전환 자동화 | NCloud/KT/LG CNS |
| e_procurement.py | 전자조달 이력 관리 | 나라장터 계약 시스템 |
**나라장터 연동 기능:**
- 기관별 입찰 공고 조회 → ITSM 프로젝트 자동 생성
- 계약 현황 → SR 이행 연계
- 납품 검수 → CMDB 자동 등록
**공공 API 허브 지원 API:**
- 기상청 날씨 (서버실 온습도 모니터링 연계)
- 행안부 주소 API (사이트 주소 자동완성)
- 국세청 사업자 정보 (공급사 검증)
- KISA CVE 취약점 정보 (vuln_scan 연계)
---
## 추가 고려 영역 (향후)
### 그린 IT / 탄소 발자국 (P3)
- 서버 전력 소비량 측정 (IPMI/BMC)
- 탄소 배출량 계산 (전력 → CO2 환산)
- 에너지 효율 개선 권고
### 이벤트 스트리밍 (P3)
- Kafka/NATS 기반 실시간 이벤트 버스
- 장애 이벤트 → 즉시 SR 생성 (현재 폴링 방식 개선)
### MDM (Mobile Device Management) (P3)
- 업무용 모바일 기기 관리
- 원격 초기화·정책 배포
### 제로 트러스트 (P3)
- ZTNA 정책 관리
- 마이크로 세그멘테이션 설정
---
## 예상 신규 라우터 수
| 영역 | 라우터 수 | 예상 엔드포인트 |
|------|---------|--------------|
| CMDB 자동 발견 | 4개 | ~20개 |
| Text-to-SQL | 3개 | ~12개 |
| 구성 드리프트 | 3개 | ~15개 |
| 멀티클라우드 | 4개 | ~20개 |
| 공공기관 특화 | 6개 | ~30개 |
| **합계** | **20개** | **~97개** |
**확장 후 총계: 124개 라우터, ~764개 엔드포인트**

250
.claude/skills/guardia-enhance-orchestrator/SKILL.md
View File

@ -1,250 +0,0 @@
---
name: guardia-enhance-orchestrator
description: >
GUARDiA 기능 개선 및 추가 오케스트레이터. 기존 기능 UX 개선과 신규 기능 추가를 에이전트 팀으로 병렬 구현한다.
핵심: (1) 모바일 앱 QR 코드 직접 배포 — Manager에 APK 업로드 → QR 생성 → 앱스토어 없이 설치,
(2) ITSM 준비중 뷰 8개 완성 + 배치 SSH + 의존성 맵,
(3) 웹메일 주소록·서명·폴더 고도화,
(4) 자산 QR 태그 — 서버에 QR 부착 → 스캔 → CMDB 조회,
(5) 알림 규칙 노코드 편집기 + 스마트 필터.
다음 상황에서 반드시 사용:
(1) '앱 QR 배포', 'APK 직접 배포', '앱스토어 없이 설치', 'QR 코드 앱';
(2) 'ITSM 개선', '준비중 뷰 완성', '배치 SSH', '의존성 맵 시각화';
(3) '웹메일 주소록', '메일 서명', '폴더 관리';
(4) 'QR 자산 태그', '서버 QR', '자산 실사';
(5) '알림 규칙 편집', '스마트 알림', '알림 피로도';
(6) 다시 실행, 업데이트, 수정, 보완.
---
# GUARDiA 기능 개선 및 추가 오케스트레이터
**실행 모드:** 에이전트 팀 (5명 병렬)
- app-distribution-dev: 앱 QR 배포
- itsm-ux-dev: ITSM UX 개선
- mail-enhance-dev: 웹메일 고도화
- asset-qr-dev: 자산 QR 태그
- notification-ui-dev: 알림 규칙 편집기
---
## 배경: 왜 이 기능들인가?
### 앱 QR 배포 (가장 높은 우선순위)
```
문제: 공공기관은 Play Store/App Store 등록이 복잡·느림
해결: 관리자가 APK 업로드 → QR 생성 → 사용자 스캔 → 즉시 설치
효과: 앱 배포 시간 수일 → 수분
```
### ITSM UX 개선
```
문제: 확장 기능들의 뷰가 "준비 중"으로 표시됨 (8개)
해결: 실제 데이터와 연결된 UI 완성
```
### 웹메일 고도화
```
문제: 현재 받은메함·작성만 가능 → 실무 사용 어려움
해결: 주소록 자동완성 + 서명 + 폴더 관리
```
---
## Phase 0: 컨텍스트 확인
```
_workspace/ 없음 → 초기 구현
있음 + 앱배포만 → app-distribution-dev 재실행
있음 + 웹메일만 → mail-enhance-dev 재실행
있음 + 전체 → _workspace_prev/ 이동 후 재실행
```
---
## Phase 1: 5개 영역 병렬 구현
### app-distribution-dev 작업
```
1. workspace/guardia-itsm/routers/app_deploy.py (신규)
- APK 업로드, QR 생성, 랜딩 페이지
2. workspace/guardia-manager/frontend/src/pages/AppDistribution.tsx (신규)
- APK 업로드 UI, QR 코드 표시, 버전 관리
3. pip install qrcode[pil] (서버)
4. DB: tb_app_version, tb_app_download_log
```
### itsm-ux-dev 작업
```
1. workspace/guardia-itsm/routers/batch_ssh.py (신규)
- 다중 서버 SSH 일괄 실행
2. workspace/guardia-itsm/static/app.js (수정)
- batch_ssh, dependency_view, snmp_devices,
inventory_view 등 8개 뷰 완성
3. workspace/guardia-itsm/static/index.html (수정)
- 누락 사이드바 메뉴 추가
4. DB: tb_batch_ssh_job
```
### mail-enhance-dev 작업
```
1. workspace/zioinfo-mail/backend/contacts.py (신규)
2. workspace/zioinfo-mail/backend/signature.py (신규)
3. workspace/zioinfo-mail/frontend/src/components/Contacts.tsx (신규)
4. workspace/zioinfo-mail/frontend/src/components/SignatureEditor.tsx (신규)
5. DB: tb_mail_contact, tb_mail_signature
```
### asset-qr-dev 작업
```
1. workspace/guardia-itsm/routers/asset_qr.py (신규)
- QR 토큰 생성, 스캔, 라벨 인쇄
2. workspace/guardia-itsm/static/app.js (수정)
- asset_qr 뷰 추가
3. workspace/guardia-messenger/app/(tabs)/scan.tsx (신규)
- QR 스캔 탭
4. DB: tb_asset_qr_token, tb_asset_qr_scan_log
```
### notification-ui-dev 작업
```
1. workspace/guardia-itsm/routers/smart_notify.py (신규)
- 규칙 CRUD, 스마트 필터, 무음 설정
2. workspace/guardia-manager/frontend/src/pages/NotificationRules.tsx (신규)
- 드래그앤드롭 규칙 편집기
3. workspace/guardia-itsm/static/app.js (수정)
- notification_rules 뷰 추가
4. DB: tb_smart_notify_rule, tb_notify_log
```
---
## Phase 2: DB 모델 + main.py 등록
### ITSM 신규 라우터 등록
```python
from routers import app_deploy, batch_ssh, asset_qr, smart_notify
app.include_router(app_deploy.router) # APK 배포 + QR
app.include_router(batch_ssh.router) # 배치 SSH
app.include_router(asset_qr.router) # 자산 QR 태그
app.include_router(smart_notify.router) # 스마트 알림
```
### 웹메일 신규 라우터 등록
```python
# zioinfo-mail/backend/main.py
from contacts import router as contacts_router
from signature import router as signature_router
app.include_router(contacts_router)
app.include_router(signature_router)
```
### Manager 신규 라우트 등록
```typescript
// App.tsx
const AppDistribution = lazy(() => import('./pages/AppDistribution'))
const NotificationRules = lazy(() => import('./pages/NotificationRules'))
<Route path="app-distribution" element={<AppDistribution />} />
<Route path="notification-rules" element={<NotificationRules />} />
```
---
## Phase 3: QR 배포 시스템 상세 흐름
```
관리자:
Manager → 앱 배포 페이지 → APK 파일 업로드
→ 서버 저장 (/opt/guardia/app/uploads/apk/)
→ QR 코드 자동 생성 (랜딩 페이지 URL 인코딩)
→ QR 이미지 표시 + 공유 버튼
사용자 (Android):
QR 스캔 → 랜딩 페이지
→ "Android 다운로드" 클릭
→ APK 다운로드 → 설치 (알 수 없는 출처 허용)
→ GUARDiA Messenger 설치 완료!
사용자 (iOS):
QR 스캔 → 랜딩 페이지
→ "TestFlight" 또는 "App Store" 링크
관리자 대시보드:
다운로드 횟수 실시간 집계
기기별 통계 (Android/iOS/버전)
구버전 자동 만료 처리
```
---
## Phase 4: QA 검증
```
1. APK 업로드 → QR 생성 → 스캔 → 다운로드 E2E
2. 배치 SSH → 3개 서버 동시 실행 → 결과 수집
3. 주소록 → 메일 작성 → 자동완성 동작
4. 서버 QR → 스캔 → CMDB 정보 표시
5. 알림 규칙 → 조건 설정 → 테스트 발송
```
---
## 신규 라우터 목록 (예상 엔드포인트)
| 영역 | 파일 | 엔드포인트 수 |
|------|------|-------------|
| 앱 배포 | app_deploy.py | 9개 |
| 배치 SSH | batch_ssh.py | 4개 |
| 자산 QR | asset_qr.py | 8개 |
| 스마트 알림 | smart_notify.py | 7개 |
| 주소록 | contacts.py | 6개 |
| 서명 | signature.py | 2개 |
| **합계** | | **~36개** |
**목표: 774 → ~810개 엔드포인트**
---
## 테스트 시나리오
**정상 흐름 (APK 배포):**
1. Manager → 앱 배포 → "APK 업로드" 클릭
2. GUARDiA_Messenger_v1.0.0.apk 선택 → 업로드
3. QR 코드 자동 생성 표시
4. Android폰으로 QR 스캔 → 다운로드 페이지
5. "Android 다운로드" → APK 설치 완료
**정상 흐름 (자산 QR):**
1. ITSM → QR 자산 관리 → 서버 선택
2. "QR 생성" → 라벨 인쇄
3. 서버 장비에 라벨 부착
4. Messenger 앱 QR 탭으로 스캔
5. CMDB 정보 표시 + "실사 완료" 체크인
---
## should-trigger
- "앱 QR 배포", "APK 배포", "앱스토어 없이 설치"
- "ITSM 개선", "준비중 뷰", "배치 SSH"
- "웹메일 주소록", "메일 서명", "폴더 관리"
- "자산 QR", "서버 QR 태그", "자산 실사"
- "알림 규칙 편집기", "스마트 알림"
- "다시 실행", "수정", "보완"
## should-NOT-trigger
- "앱 개발" → messenger-orchestrator
- "ITSM SR 처리" → guardia-orchestrator
- "Upstage OCR" → upstage-ocr-orchestrator

248
.claude/skills/guardia-expansion-orchestrator/SKILL.md
View File

@ -1,248 +0,0 @@
---
name: guardia-expansion-orchestrator
description: >
GUARDiA ITSM 플랫폼 확장 오케스트레이터. 현재 81개 라우터에서 다음 5개 영역으로 확장한다:
(1) 클라우드·컨테이너 인프라 관리 (Kubernetes/Docker/NCloud),
(2) AI 플랫폼 고도화 (RAG 강화, 자율 워크플로우, 멀티모달),
(3) 멀티테넌트 SaaS 확장 (화이트라벨, 구독, 기관 온보딩),
(4) 엔터프라이즈 통합 (Jira/Slack/ServiceNow/ERP/SSO),
(5) 비즈니스 인텔리전스 (KPI 엔진, 예측 분석, 자동 보고서).
guardia-itsm 기존 패턴(FastAPI+SQLAlchemy+paramiko) 준수. 외부 API 완전 금지.
다음 상황에서 반드시 사용:
(1) 'GUARDiA 확장', '신규 기능 추가', '가디아 고도화';
(2) Kubernetes/Docker/컨테이너/클라우드 관리 기능;
(3) AI RAG/자율화/멀티모달 고도화;
(4) SaaS/화이트라벨/구독/온보딩 구현;
(5) Jira/Slack/ServiceNow/ERP/SSO 연동;
(6) KPI/BI 대시보드/예측 분석/자동 보고서;
(7) 다시 실행, 업데이트, 수정, 보완.
---
# GUARDiA 플랫폼 확장 오케스트레이터
**실행 모드:** 하이브리드
- Phase 1 (현황 분석): 서브 에이전트 (itsm-dev — 기존 코드베이스 분석)
- Phase 2~4 (구현): **에이전트 팀** (cloud-container-dev + ai-platform-dev + saas-platform-dev + enterprise-integrator + bi-analytics-dev)
- Phase 5 (QA): 서브 에이전트 (cross-system-qa)
---
## Phase 0: 컨텍스트 확인
```
_workspace/ 존재 여부:
- 없음 → 초기 구현 (Phase 1부터)
- 있음 + 특정 영역 요청 → 해당 에이전트만 재실행
예: "Jira 연동만 다시" → enterprise-integrator만 Phase 3 재실행
- 있음 + 전체 재구성 → _workspace/ → _workspace_prev/ 이동 후 전체 재실행
```
---
## Phase 1: 현황 분석 (서브 에이전트)
**itsm-dev** 서브 에이전트로 실행:
```
분석 항목:
1. workspace/guardia-itsm/routers/ 전체 파일 목록
2. 각 확장 영역과 기존 라우터 중복 분석
- cloud: ssh.py, infra_ext.py, scouter.py → 재사용 가능
- ai: anomaly.py, chatbot.py, kb_agent.py, autonomous.py → 확장 기반
- saas: tenant_mgmt.py, onboarding.py, license.py → 확장 기반
- integration: gateway.py, ldap.py, groupware.py → 확장 기반
- bi: analytics.py, finops.py, sla.py, report.py → 확장 기반
3. 확장 구현 시 사용할 공통 유틸 파악
4. DB 모델에서 재사용 가능한 테이블 파악
```
산출물: `_workspace/01_analysis_report.md`
---
## Phase 2: 5개 영역 병렬 설계 (에이전트 팀)
**팀 구성 (TeamCreate):**
- 리더: orchestrator
- 팀원: cloud-container-dev, ai-platform-dev, saas-platform-dev, enterprise-integrator, bi-analytics-dev
**작업 할당 (TaskCreate):**
| 에이전트 | 작업 | 산출물 |
|---------|------|--------|
| cloud-container-dev | kubernetes.py, docker_mgr.py, ncloud.py, container_alerts.py 설계 | `_workspace/02_cloud_spec.md` |
| ai-platform-dev | rag_engine.py, autonomous_workflow.py, ai_insights.py, multimodal.py, learning_loop.py 설계 | `_workspace/03_ai_spec.md` |
| saas-platform-dev | tenant_portal.py, white_label.py, subscription.py, billing.py, onboarding.py 설계 | `_workspace/04_saas_spec.md` |
| enterprise-integrator | jira_sync.py, slack_connector.py, servicenow.py, erp_connector.py, sso_provider.py, kakao_notify.py 설계 | `_workspace/05_integration_spec.md` |
| bi-analytics-dev | bi_dashboard.py, kpi_engine.py, predictive_ops.py, auto_report.py, benchmark.py 설계 | `_workspace/06_bi_spec.md` |
**팀원 간 인터페이스 조율 (SendMessage):**
- cloud → ai: 컨테이너 이상 이벤트 스키마
- ai → bi: 예측 모델 API 인터페이스
- saas → integration: SSO 연동 요청 스키마
- integration → bi: 외부 데이터 수집 API
---
## Phase 3: 구현 (에이전트 팀 계속)
### 구현 우선순위
**P1 (즉시 구현 — 고가치·저복잡도):**
```
1. ai/rag_engine.py — 기존 pgvector + Ollama, 즉각 효과
2. integration/jira_sync.py — 고객 요청 최다
3. bi/kpi_engine.py — 기존 analytics 기반 빠른 구현
4. saas/tenant_portal.py — 기존 tenant_mgmt 확장
```
**P2 (다음 스프린트 — 중간 복잡도):**
```
5. cloud/kubernetes.py — SSH 경유 kubectl, 에이전트리스 유지
6. ai/autonomous_workflow.py — 기존 autonomous.py 고도화
7. integration/sso_provider.py — SAML/OIDC
8. bi/predictive_ops.py — ML 모델 적용
```
**P3 (장기 — 고복잡도):**
```
9. saas/billing.py — 과금 시스템
10. integration/servicenow.py — 외부 ITSM 연동
11. ai/learning_loop.py — 파인튜닝 파이프라인
12. bi/benchmark.py — 멀티테넌트 비교 분석
```
### 구현 원칙 (모든 에이전트 공통)
```python
# 1. 라우터 등록 (workspace/guardia-itsm/main.py)
from routers import kubernetes, rag_engine, tenant_portal, jira_sync, kpi_engine
app.include_router(kubernetes.router, prefix="/api/k8s", tags=["Cloud"])
app.include_router(rag_engine.router, prefix="/api/rag", tags=["AI"])
# 2. 보안 — 모든 엔드포인트 JWT 필수
from core.auth import get_current_user
@router.get("/clusters")
async def list_clusters(user=Depends(get_current_user)):
...
# 3. 테넌트 격리 — 모든 쿼리에 tenant_id 적용
clusters = await db.execute(
select(K8sCluster).where(K8sCluster.tenant_id == user.tenant_id)
)
# 4. 에러 응답 — SR ID만 노출
raise HTTPException(500, detail=f"SR-{sr_id}: 서버 오류")
```
---
## Phase 4: DB 마이그레이션
각 에이전트가 생성한 신규 모델을 DB에 반영:
```python
# workspace/guardia-itsm/migrations/v3_expansion.py
from alembic import op
import sqlalchemy as sa
def upgrade():
# Cloud
op.create_table('tb_k8s_cluster', ...)
op.create_table('tb_docker_service', ...)
# AI
op.create_table('tb_auto_workflow', ...)
op.create_table('tb_rag_feedback', ...)
# SaaS
op.create_table('tb_tenant_branding', ...)
op.create_table('tb_subscription', ...)
# Integration
op.create_table('tb_jira_sync', ...)
op.create_table('tb_connector_config', ...)
# BI
op.create_table('tb_kpi', ...)
op.create_table('tb_kpi_value', ...)
```
---
## Phase 5: QA (서브 에이전트)
**cross-system-qa** 서브 에이전트:
```
검증 항목:
1. 신규 라우터 임포트 오류 없음
2. JWT 인증 누락 엔드포인트 없음
3. 테넌트 격리 누락 쿼리 없음
4. 외부 API 호출 코드 없음 (온프레미스 원칙)
5. ServerOut 스키마에 민감 정보 노출 없음
6. 각 라우터의 /docs 표시 확인
```
---
## 데이터 흐름
```
_workspace/
├── 01_analysis_report.md ← itsm-dev (기존 코드 분석)
├── 02_cloud_spec.md ← cloud-container-dev
├── 03_ai_spec.md ← ai-platform-dev
├── 04_saas_spec.md ← saas-platform-dev
├── 05_integration_spec.md ← enterprise-integrator
├── 06_bi_spec.md ← bi-analytics-dev
└── 07_qa_report.md ← cross-system-qa
```
---
## 에러 핸들링
| 에러 | 처리 |
|------|------|
| 기존 라우터와 충돌 | Phase 1 분석 재실행, 접두사 변경 |
| DB 마이그레이션 실패 | 롤백 후 에러 보고 |
| 외부 API 호출 발견 | 즉시 중단, 온프레미스 대안 제시 |
| 테넌트 격리 누락 | QA에서 감지, 해당 에이전트 재호출 |
---
## 확장 로드맵
상세 로드맵은 `references/expansion-roadmap.md` 참조.
---
## 테스트 시나리오
**정상 흐름:**
1. "K8s 클러스터 관리 기능 추가해줘"
2. Phase 1: itsm-dev가 ssh.py, infra_ext.py 분석
3. Phase 2: cloud-container-dev가 kubernetes.py 설계
4. Phase 3: kubernetes.py 구현 + main.py 등록
5. Phase 5: QA — JWT 확인, 테넌트 격리 확인
6. "✅ Kubernetes 클러스터 관리 API 추가 완료"
**에러 흐름:**
- kubernetes.py에서 외부 K8s API 직접 호출 → QA 감지 → SSH 경유로 재구현
---
## should-trigger
- "가디아 확장해줘"
- "K8s 관리 기능 추가"
- "Jira 연동 구현"
- "KPI 대시보드 만들어줘"
- "화이트라벨 기능"
- "RAG 강화해줘"
- "구독 관리 시스템"
- "다시 실행", "수정", "보완"
## should-NOT-trigger
- "guardia-itsm SR 접수해줘" → guardia-orchestrator
- "ITSM UI 개편" → ui-overhaul-orchestrator
- "CI/CD 파이프라인" → cicd-pipeline-orchestrator
- "5개 시스템 배포 확인" → system-sync-orchestrator

229
.claude/skills/guardia-expansion-orchestrator/references/expansion-roadmap.md
View File

@ -1,229 +0,0 @@
# GUARDiA 플랫폼 확장 로드맵
## 현황 (2026-06-01 기준)
| 카테고리 | 구현 완료 | 미구현 |
|---------|---------|--------|
| ITSM 핵심 | SR, CMDB, CAB, Problem, SLA, SVC Catalog | — |
| AI/자동화 | Anomaly, Chatbot, Code Review, KB Agent, RPA, Scraping | RAG 강화, 자율 워크플로우, 멀티모달 |
| 인프라 | SSH, Scouter APM, infra_ext, shell_scripts | Kubernetes, Docker, NCloud |
| 보안 | LDAP, PAM, OTP, Vuln Scan, CSAP, Audit | SSO(SAML), 위협 헌팅 |
| 리포트 | analytics, sla, report, finops | KPI 엔진, 예측 분석, 벤치마킹 |
| 통합 | gateway, groupware | Jira, Slack, ServiceNow, ERP |
| SaaS | tenant_mgmt, license, onboarding | 화이트라벨, 구독, 과금 |
| SI 관리 | si_projects, si_wbs, si_milestones | — |
| DR/네트워크 | dr.py, network_devices.py | — |
---
## Phase 1 확장 (즉시 — P1)
### 1-1. AI RAG 강화 (`rag_engine.py`)
**목표:** 현재 단순 벡터 검색 → 하이브리드 검색(BM25+벡터) + 재순위화
```
현재: 쿼리 → pgvector → Ollama
목표: 쿼리 → BM25+pgvector → Cross-Encoder 재순위 → Ollama
```
**구현 포인트:**
- `pgvector` 기존 임베딩 재사용
- PostgreSQL FTS (Full-Text Search) 추가
- RRF(Reciprocal Rank Fusion) 결합 알고리즘
- 피드백 루프: 사용자 평점 → 검색 품질 개선
**예상 효과:** SR 자동 분류 정확도 15% 향상, 지식베이스 검색 응답 품질 개선
---
### 1-2. Jira 양방향 동기화 (`jira_sync.py`)
**목표:** SR ↔ Jira Issue 실시간 동기화
```
SR 생성 → Jira Issue 자동 생성
Jira 상태 변경 → SR 상태 자동 업데이트
코멘트 양방향 동기화
첨부파일 동기화
```
**구현 포인트:**
- Jira REST API v3 (Cloud) + Jira Server API
- Webhook 수신 (Jira → GUARDiA)
- 상태 매핑 테이블 (기관별 커스터마이즈)
- 멀티테넌트: 기관마다 별도 Jira 설정
---
### 1-3. KPI 엔진 (`kpi_engine.py`)
**목표:** 기관별 KPI 정의·계산·목표 추적 대시보드
```
지표 예시:
- MTTR (평균 복구 시간): 목표 < 4시간
- FCR (첫 번째 해결율): 목표 > 80%
- SLA 준수율: 목표 > 95%
- SR 적체율: 목표 < 10건
```
**구현 포인트:**
- KPI 정의는 SQL/Python 식으로 커스터마이즈
- 일별/주별/월별 자동 계산 (APScheduler)
- 목표 대비 신호등 상태 (RED/YELLOW/GREEN)
- 기존 `analytics.py` 데이터 재사용
---
### 1-4. 테넌트 셀프서비스 포털 (`tenant_portal.py`)
**목표:** 기관 관리자가 직접 설정 관리 (GUARDiA Manager 연동)
```
기관 관리자 권한:
- 사용자 등록/삭제/역할 변경
- 서버 자산 등록
- 알림 설정 (수신자, 임계값)
- 비밀번호 정책 설정
```
---
## Phase 2 확장 (1~2개월 — P2)
### 2-1. Kubernetes 관리 (`kubernetes.py`)
**에이전트리스 K8s 관리:**
```bash
# SSH 경유 kubectl 실행
ssh opsagent@k8s-master "kubectl get pods -n production -o json"
ssh opsagent@k8s-master "kubectl rollout restart deployment/app"
```
**기능 목록:**
- 클러스터/네임스페이스/Pod 현황 조회
- Deployment 롤링 업데이트 트리거
- HPA(수평 자동 확장) 현황 조회
- Pod 로그 실시간 스트리밍 (WebSocket)
- 리소스 사용률 수집 (CPU/메모리/디스크)
---
### 2-2. 자율 워크플로우 엔진 (`autonomous_workflow.py`)
**현재 autonomous.py 확장:**
```python
# 기존: 단순 자동 승인 큐
# 목표: 조건 기반 자동 실행 워크플로우
{
"trigger": "SR_CREATED",
"condition": "sr.category == 'MONITORING' AND sr.priority < 3",
"actions": [
{"type": "AUTO_ASSIGN", "rule": "ROUND_ROBIN"},
{"type": "NOTIFY", "channel": "messenger"},
{"type": "HEALTH_CHECK", "delay_minutes": 5}
],
"approval_required": false
}
```
---
### 2-3. SSO 통합 (`sso_provider.py`)
**행정안전부 공통로그인 + 기업 IdP 지원:**
- SAML 2.0 (행정안전부 GPKI, 국가정보자원관리원)
- OIDC/OAuth2 (Google Workspace, Microsoft Entra)
- LDAP/AD (기존 `ldap.py` 활용)
---
### 2-4. 예측 운영 분석 (`predictive_ops.py`)
**기존 predictive.py 고도화:**
```python
# 7일 후 장애 발생 확률 예측
{
"server_id": 42,
"failure_probability_7d": 0.78,
"main_indicators": ["CPU 트렌드", "디스크 증가율"],
"recommended_action": "긴급 점검 SR 생성",
"confidence": 0.85
}
```
---
## Phase 3 확장 (3~6개월 — P3)
### 3-1. 구독·과금 시스템 (`subscription.py`, `billing.py`)
```
플랜: COMMUNITY → STANDARD → ENTERPRISE
서버 수: 20 → 200 → 무제한
사용자 수: 10 → 100 → 무제한
가격(월): 무료 → 50만원 → 협의
청구 주기: 월납 / 연납 (10% 할인)
```
### 3-2. 멀티모달 AI (`multimodal.py`)
```
입력: 스크린샷, 로그 파일, 에러 이미지
처리: Ollama llava 모델
출력: 에러 분류, 해결 방법, SR 자동 생성
```
### 3-3. 기관 간 벤치마킹 (`benchmark.py`)
```
익명화된 업계 평균과 비교:
- 우리 기관 MTTR vs 공공기관 평균 MTTR
- SR 처리 속도 순위 (익명 백분위)
- SLA 준수율 업계 평균 대비
```
### 3-4. Self-Improving Learning Loop (`learning_loop.py`)
```
1. 사용자 피드백 수집 (AI 응답 평가)
2. 저품질 응답 샘플 수집
3. Ollama 파인튜닝 데이터셋 생성
4. 모델 파인튜닝 (주 1회 자동 실행)
5. 성능 비교 후 배포 (A/B 테스트)
```
---
## 신규 라우터 목록 (전체)
| 영역 | 파일명 | 우선순위 |
|------|-------|---------|
| Cloud | kubernetes.py | P2 |
| Cloud | docker_mgr.py | P2 |
| Cloud | ncloud.py | P3 |
| Cloud | container_alerts.py | P2 |
| AI | rag_engine.py | **P1** |
| AI | autonomous_workflow.py | P2 |
| AI | ai_insights.py | P2 |
| AI | multimodal.py | P3 |
| AI | learning_loop.py | P3 |
| SaaS | tenant_portal.py | **P1** |
| SaaS | white_label.py | P2 |
| SaaS | subscription.py | P3 |
| SaaS | billing.py | P3 |
| Integration | jira_sync.py | **P1** |
| Integration | slack_connector.py | P2 |
| Integration | servicenow.py | P3 |
| Integration | erp_connector.py | P2 |
| Integration | sso_provider.py | P2 |
| Integration | kakao_notify.py | P2 |
| BI | bi_dashboard.py | **P1** |
| BI | kpi_engine.py | **P1** |
| BI | predictive_ops.py | P2 |
| BI | auto_report.py | P2 |
| BI | benchmark.py | P3 |
| BI | cohort_analysis.py | P3 |
**총 25개 신규 라우터** (P1: 6개, P2: 11개, P3: 8개)

132
.claude/skills/guardia-fullstack-orchestrator/SKILL.md
View File

@ -1,132 +0,0 @@
---
name: guardia-fullstack-orchestrator
description: "GUARDiA 전체 시스템(ITSM·홈페이지·Manager·Messenger) 크로스 시스템 작업 오케스트레이터. 신기능 추가, 시스템 간 연동 수정, API 계약 변경, 통합 배포 등 여러 시스템에 걸친 작업을 조율한다. 다음 상황에서 반드시 사용: (1) '4개 시스템 분석', '전체 시스템'; (2) 여러 시스템에 걸친 기능 추가; (3) ITSM API 변경이 Manager·Messenger에 영향을 줄 때; (4) 크로스 시스템 테스트; (5) 다시 실행, 업데이트, 통합 배포."
---
# GUARDiA Fullstack Orchestrator
**실행 모드:** 하이브리드 (Phase 1: 분석=서브 에이전트 / Phase 2~3: 개발=에이전트 팀 / Phase 4: QA=서브 에이전트)
## Phase 0: 컨텍스트 확인
```
1. _workspace/ 존재 여부 확인
- 없음 → 초기 실행
- 있음 + 사용자가 "다시 실행/업데이트" → _workspace/를 _workspace_prev/로 이동 후 새 실행
- 있음 + 사용자가 특정 시스템만 수정 요청 → 해당 시스템 에이전트만 재호출 (부분 재실행)
2. 작업 유형 분류:
A. 단일 시스템 작업 → 해당 dev 에이전트만 직접 호출
B. 크로스 시스템 작업 → Phase 1~4 전체 실행
C. 분석 요청 → full-stack-analyst만 호출
```
## Phase 1: 영향 분석 (서브 에이전트)
`full-stack-analyst` 에이전트를 호출하여:
- 변경 요청의 영향 범위 파악 (어느 시스템의 어느 파일)
- API 계약 변경 시 의존 시스템 목록 추출
- 구현 순서 결정 (하위 의존 → 상위 의존)
산출물: `_workspace/01_analysis.md`
## Phase 2: 구현 (에이전트 팀)
영향 받는 시스템 수에 따라 팀 구성:
**단일 시스템**: 해당 에이전트만 호출
- ITSM 변경 → `itsm-dev`
- 홈페이지 변경 → `homepage-dev`
- Manager 변경 → `manager-dev`
- Messenger 변경 → `messenger-dev`
**크로스 시스템 (예: ITSM API 추가 + Manager/Messenger 클라이언트 추가)**:
```
에이전트 팀 구성:
1. itsm-dev — ITSM router/model 먼저 구현 (기반)
2. manager-dev — ITSM 구현 완료 후 Manager 클라이언트 구현
3. messenger-dev — Messenger 화면/훅 구현 (manager-dev와 병렬 가능)
```
**구현 순서 규칙**:
1. DB 모델 변경 (models.py) → 2. ITSM 라우터 → 3. Manager API 클라이언트 → 4. Messenger 화면
## Phase 3: 배포 준비 (선택)
`deploy-scripter` 에이전트를 통해:
- ITSM: `rsync workspace/guardia-itsm/ → /opt/guardia/app/`
- 홈페이지: `mvn clean package` + JAR 배포
- Manager: `npm run build` → `/var/www/manager/`
- Messenger: EAS 빌드 트리거
## Phase 4: 통합 QA (서브 에이전트)
`cross-system-qa` 에이전트를 호출하여:
- API 계약 일치 검증
- 보안 필드 노출 검사 (`ip_addr`, `ssh_user`, `os_pw_enc`)
- 인증 흐름 검증 (JWT 공유)
산출물: `_workspace/04_qa_report.md`
---
## 시스템별 빠른 참조
시스템 상세 정보가 필요하면 `references/system-landscape.md`를 읽어라.
### ITSM 신규 라우터 추가 체크리스트
- [ ] `workspace/guardia-itsm/routers/새파일.py` 생성
- [ ] `workspace/guardia-itsm/main.py`에 import + `app.include_router()` 추가
- [ ] `workspace/guardia-itsm/models.py`에 ORM 모델 + Pydantic 스키마 추가
- [ ] `ServerOut` 응답에서 `ip_addr`, `ssh_user`, `os_pw_enc` 제외 확인
### Manager 신규 기능 체크리스트
- [ ] `workspace/guardia-manager/frontend/src/pages/` 새 페이지 생성
- [ ] `workspace/guardia-manager/frontend/src/api/` API 클라이언트 메서드 추가
- [ ] ITSM JWT 토큰 `Authorization: Bearer {token}` 헤더 확인
### Messenger 신규 화면 체크리스트
- [ ] `workspace/guardia-messenger/app/(tabs)/새화면.tsx` 생성
- [ ] `workspace/guardia-messenger/app/(tabs)/_layout.tsx`에 탭 등록
- [ ] EAS 금지 패턴 4종 위반 여부 확인
---
## 에러 핸들링
| 상황 | 처리 |
|------|------|
| ITSM 라우터 import 실패 | models.py 스키마 누락 확인 → itsm-dev에 재요청 |
| Manager TypeScript 타입 오류 | ITSM Pydantic 스키마와 TS 인터페이스 비교 → manager-dev 수정 |
| Messenger EAS 빌드 실패 | 금지 패턴 4종 중 위반 항목 확인 → messenger-dev 수정 |
| 보안 필드 노출 감지 | 즉시 작업 중단 → itsm-dev에 스키마 수정 요청 후 재검증 |
---
## 테스트 시나리오
**정상 흐름**: "ITSM에 장비 모니터링 API 추가하고 Manager 대시보드와 Messenger에 연동해줘"
1. full-stack-analyst: 영향 범위 분석 → ITSM+Manager+Messenger 3개 시스템
2. itsm-dev: `routers/monitor.py` 생성 → main.py 등록
3. manager-dev: `/api/monitor` 호출 클라이언트 + 대시보드 위젯
4. messenger-dev: `(tabs)/monitor.tsx` 화면 추가
5. cross-system-qa: API shape 검증, 보안 필드 검사
**에러 흐름**: Manager에서 ITSM API 404 발생
1. cross-system-qa: ITSM 라우터 엔드포인트 vs Manager API 클라이언트 URL 대조
2. 불일치 발견 → manager-dev에 URL 수정 요청
3. 재검증
---
## 후속 작업 지원
이 스킬은 다음 상황에서도 트리거된다:
- "다시 실행", "업데이트", "수정", "보완"
- "ITSM과 Manager 연동 확인"
- "Messenger 화면 추가"
- "전체 시스템 배포"
- "API 계약 검증", "보안 스캔"

161
.claude/skills/guardia-fullstack-orchestrator/references/system-landscape.md
View File

@ -1,161 +0,0 @@
# GUARDiA 시스템 랜드스케이프
## 4개 시스템 전체 맵
### 1. GUARDiA ITSM (중앙 허브)
```
경로: workspace/guardia-itsm/
URL: http://localhost:9001 / https://zioinfo.co.kr:8443 (OpenNet)
언어: Python 3.11 + FastAPI 0.115+
DB: SQLite (dev) / PostgreSQL 16 (prod)
LLM: Ollama localhost:11434 (codellama:7b, llama3:8b, nomic-embed-text)
```
**라우터 카테고리 (75개+)**
| 카테고리 | 라우터 | 설명 |
|---------|--------|------|
| 인증/권한 | auth, ldap, pam, otp | JWT, LDAP/AD, 특권접근, 2FA |
| SR 관리 | tasks, approvals, assign, batch | SR CRUD, 승인, 자동배정 |
| CMDB | cmdb, servers | 서버 자산, CI 관계 |
| AI | chatbot, code_review, anomaly, kb_agent, orchestrator, predictive | Ollama 연동 |
| 운영 | incidents, oncall, dr, network_devices | 인시던트, DR, 네트워크 |
| 보안 | audit, vuln_scan, siem, compliance, csap | 감사, 취약점, CSAP |
| 분석 | analytics, sla, metrics, finops, report | 대시보드, Grafana |
| 자동화 | rpa, scraping, autonomous, ssh | RPA봇, 스크래핑, SSH |
| SI 관리 | si_projects, si_wbs, si_requirements, si_issues 등 | SI 프로젝트 |
| 연동 | external_api, export_import, gateway, groupware | 외부 시스템 |
| 기관 | institutions, tenant_mgmt | 멀티테넌트 |
**핵심 API 엔드포인트**
```
POST /api/auth/login → JWT 발급
GET /api/tasks → SR 목록
POST /api/tasks → SR 생성
GET /api/dashboard → 대시보드 통계
GET /api/cmdb/servers → 서버 자산
POST /api/rpa/execute → RPA 실행
GET /api/scraping/stats → 스크래핑 통계
POST /api/autonomous/approve/{id} → 자율처리 승인
WS /ws/notifications → 실시간 알림
```
---
### 2. zioinfo-web (홈페이지)
```
경로: workspace/zioinfo-web/
URL: http://localhost:8082 / https://zioinfo.co.kr:8082
언어: Java 17 + Spring Boot 3.2.5
DB: SQLite (dev) / MySQL (prod)
빌드: mvn clean package -DskipTests → target/zioinfo-web-1.0.0.jar
배포: /opt/zioinfo/app/app.jar → systemctl restart zioinfo
```
**DB 엔티티 현황**
| 엔티티 | 테이블 | 공개 API | 관리자 API |
|--------|--------|---------|-----------|
| News | tb_news | GET /api/news | /api/admin/news |
| Recruit | tb_recruit | GET /api/recruit | /api/admin/recruit |
| Inquiry | tb_inquiry | POST /api/inquiry | /api/admin/inquiries |
| CompanyHistory | tb_company_history | GET /api/history | /api/admin/history |
| Member | tb_member | - | /api/admin/members |
**프론트엔드 페이지 (React 18/Vite)**
공개: Home, Company, Business, SolutionPage, GuardiaDetail, NewsPage, Recruit, Contact, Support
관리자: AdminDashboard, AdminNews, AdminRecruit, AdminInquiry, AdminHistory, AdminSettings, AdminMember
---
### 3. GUARDiA Manager (관리자 포털)
```
경로: workspace/guardia-manager/
URL: http://localhost:8090 (Nginx 서브)
백엔드: Python FastAPI 포트 8002
프론트: React 18 TypeScript + Vite → /var/www/manager/
인증: ITSM JWT 재사용 (별도 DB 없음)
```
**백엔드 라우터 (4개)**
| 라우터 | 접두사 | 역할 |
|--------|--------|------|
| system.py | /api/system | 서버 상태(psutil), 서비스 제어(systemctl) |
| deploy.py | /api/deploy | 배포 트리거, 이력 |
| config.py | /api/config | .env 편집, Nginx 리로드 |
| llm.py | /api/llm | Ollama 상태·모델 관리 |
**관리 서비스 목록** (ALLOWED_SVCS):
nginx, zioinfo, zioinfo-deploy, guardia, guardia-manager, gitea, jenkins, postgresql, ollama
---
### 4. GUARDiA Messenger (모바일 앱)
```
경로: workspace/guardia-messenger/
플랫폼: Android (APK) / iOS
빌드: EAS Build (eas build --platform android)
계정: EAS zioinfo / 프로젝트 ID ca2f72d6-7dda-4491-9590-7ace34b10a88
패키지: kr.co.zioinfo.guardia
```
**화면 목록 (9개)**
| 화면 | 경로 | ITSM API |
|------|------|---------|
| 로그인 | (auth)/login.tsx | POST /api/auth/login |
| 대시보드 | (tabs)/index.tsx | GET /api/dashboard |
| SR 관리 | (tabs)/sr.tsx | GET/POST /api/tasks |
| AI 챗봇 | (tabs)/chat.tsx | POST /api/chatbot/message (Ollama) |
| 알림 | (tabs)/notifications.tsx | WS /ws/notifications |
| 설정 | (tabs)/settings.tsx | GET /api/auth/me |
| DR 상태 | (tabs)/dr.tsx | GET /api/dr/status |
| 네트워크 | (tabs)/network.tsx | GET /api/network_devices |
---
## 시스템 간 API 의존 관계
```
┌─────────────────────────┐
│ GUARDiA ITSM (허브) │
│ localhost:9001 │
│ :8443 (OpenNet) │
└───────────┬─────────────┘
│
┌──────────────────────┼──────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────────┐
│ GUARDiA Manager │ │ Messenger (EAS) │ │ zioinfo-web (홈페이지)│
│ :8002/:8090 │ │ Android/iOS │ │ :8082 │
│ JWT 재사용 │ │ SecureStore JWT │ │ 독립 (연락처만) │
└─────────────────┘ └─────────────────┘ └─────────────────────┘
```
## 공유 인프라
| 서비스 | 포트 | 역할 |
|--------|------|------|
| Nginx | 443/8443/8082/8090/8080 | SSL 역방향 프록시 |
| PostgreSQL 16 | 5432 | ITSM 운영 DB |
| Ollama | 11434 | 온프레미스 LLM |
| Gitea | 3000/9003 | Git 저장소 |
| Jenkins | 8080/9080 | CI/CD |
| Deploy Webhook | 9999 | 자동 배포 트리거 |
## 배포 서버 정보
서버 IP: 101.79.17.164
서비스 경로:
- ITSM: `/opt/guardia/app/`
- 홈페이지: `/opt/zioinfo/app/`
- Manager: `/var/www/manager/`
- Docs: `/var/www/docs/`

228
.claude/skills/jenkinsfile-generator/SKILL.md
View File

@ -1,228 +0,0 @@
---
name: jenkinsfile-generator
description: "GUARDiA 5개 시스템(zioinfo-web, guardia-itsm, guardia-manager, guardia-messenger, guardia-docs)의 Jenkinsfile을 작성하는 스킬. 각 시스템의 빌드/테스트/배포/롤백 단계를 Groovy Pipeline DSL로 구현. 다음 상황에서 반드시 사용: (1) 'Jenkinsfile 작성', '파이프라인 작성'; (2) 특정 시스템 CI/CD 파이프라인 설계; (3) 빌드/배포 단계 추가·수정; (4) 다시 실행, 업데이트, 보완."
---
# GUARDiA Jenkinsfile 작성 스킬
## 공통 파이프라인 구조
```groovy
pipeline {
agent any
options {
buildDiscarder(logRotator(numToKeepStr: '5'))
timeout(time: 20, unit: 'MINUTES')
timestamps()
}
environment {
ITSM_BASE_URL = 'http://127.0.0.1:9001'
DEPLOY_LOG = '/var/log/zioinfo/deploy.log'
}
stages { ... }
post {
success { script { notifyITSM(success: true) } }
failure { script { notifyITSM(success: false) } }
}
}
```
---
## zioinfo-web Jenkinsfile
```groovy
pipeline {
agent any
environment {
SRC_DIR = '/opt/zioinfo/src'
JAR_DIR = '/opt/zioinfo/app'
STATIC_DIR = '/var/www/zioinfo'
MVN = '/usr/bin/mvn'
}
options {
buildDiscarder(logRotator(numToKeepStr: '5'))
timeout(time: 20, unit: 'MINUTES')
}
stages {
stage('Checkout') {
steps {
checkout([
$class: 'GitSCM', branches: scm.branches,
userRemoteConfigs: scm.userRemoteConfigs,
extensions: [[$class: 'SparseCheckoutPaths',
sparseCheckoutPaths: [[path: 'frontend'], [path: 'backend']]
]]
])
}
}
stage('Frontend Build') {
steps {
dir('frontend') {
sh 'npm ci --legacy-peer-deps --prefer-offline 2>/dev/null || npm install --legacy-peer-deps'
sh 'npm run build'
}
}
}
stage('Backend Build') {
steps {
dir('backend') {
sh "${MVN} clean package -DskipTests -q"
}
}
}
stage('Deploy') {
when { branch 'main' }
steps {
sh '''
cp backend/target/*.jar ${JAR_DIR}/app.jar
cp -r backend/src/main/resources/static/. ${STATIC_DIR}/
systemctl restart zioinfo
sleep 4
systemctl is-active zioinfo || exit 1
'''
}
}
}
post {
success { echo "✅ zioinfo-web 배포 완료" }
failure { echo "❌ zioinfo-web 빌드 실패" }
}
}
```
---
## guardia-itsm Jenkinsfile
```groovy
pipeline {
agent any
environment {
APP_DIR = '/opt/guardia/app'
VENV = '/opt/guardia/venv'
SERVICE = 'guardia'
}
options { buildDiscarder(logRotator(numToKeepStr: '5')); timeout(time: 15, unit: 'MINUTES') }
stages {
stage('Checkout') { steps { checkout scm } }
stage('Install') {
steps {
sh "${VENV}/bin/pip install -r requirements.txt -q"
}
}
stage('Test') {
when { expression { fileExists('tests/') } }
steps {
sh "${VENV}/bin/pytest tests/ -q --tb=short || true"
}
}
stage('Deploy') {
when { branch 'main' }
steps {
sh '''
rsync -a --exclude=__pycache__ --exclude=.git \
--exclude=rpa_rules.json \
. ${APP_DIR}/
systemctl restart ${SERVICE}
sleep 4
systemctl is-active ${SERVICE} || exit 1
'''
}
}
}
}
```
---
## guardia-manager Jenkinsfile
```groovy
pipeline {
agent any
environment {
SRC_DIR = '/opt/manager'
STATIC_DIR = '/var/www/manager'
SERVICE = 'guardia-manager'
}
options { buildDiscarder(logRotator(numToKeepStr: '5')); timeout(time: 15, unit: 'MINUTES') }
stages {
stage('Checkout') { steps { checkout scm } }
stage('Frontend Build') {
steps {
dir('frontend') {
sh 'npm ci 2>/dev/null || npm install'
sh 'npm run build'
}
}
}
stage('Deploy') {
when { branch 'main' }
steps {
sh '''
cp -r frontend/dist/. ${STATIC_DIR}/
systemctl restart ${SERVICE} 2>/dev/null || true
echo "Manager 배포 완료"
'''
}
}
}
}
```
---
## guardia-messenger Jenkinsfile
```groovy
pipeline {
agent any
options { buildDiscarder(logRotator(numToKeepStr: '3')); timeout(time: 30, unit: 'MINUTES') }
stages {
stage('Checkout') { steps { checkout scm } }
stage('Validate') {
steps {
sh 'node --version && npm --version'
sh 'npx eas --version 2>/dev/null || npm install -g eas-cli -q'
}
}
stage('EAS Build') {
when { branch 'main' }
steps {
withCredentials([string(credentialsId: 'expo-token', variable: 'EXPO_TOKEN')]) {
sh 'eas build --platform android --profile preview --non-interactive 2>&1 | tail -5'
}
}
}
}
post {
success { echo "📱 Messenger 빌드 완료 — expo.dev에서 확인하세요" }
}
}
```
---
## guardia-docs Jenkinsfile
```groovy
pipeline {
agent any
environment { DOCS_DIR = '/var/www/docs' }
options { buildDiscarder(logRotator(numToKeepStr: '3')) }
stages {
stage('Checkout') { steps { checkout scm } }
stage('Deploy') {
when { branch 'main' }
steps {
sh '''
mkdir -p ${DOCS_DIR}
cp -r . ${DOCS_DIR}/
echo "문서 배포 완료"
'''
}
}
}
}
```

140
.claude/skills/playwright-visual-capture/SKILL.md
View File

@ -1,140 +0,0 @@
---
name: playwright-visual-capture
description: "Playwright MCP + Variant(variant.com/community) 활용 시각적 캡처 스킬. 현재 UI Before 스크린샷, Variant 디자인 레퍼런스, 개편 후 After 스크린샷, A/B 컴포넌트 비교를 Playwright MCP 도구로 자동화한다. 다음 상황에서 반드시 사용: (1) 'UI 스크린샷 찍어줘', 'before/after 비교', 'Variant에서 디자인 찾아줘'; (2) 'UI 개편 전 현황 캡처', '반응형 검증 스크린샷'; (3) 시각적 QA, A/B 테스트 캡처; (4) 다시 실행, 업데이트, 보완."
---
# Playwright MCP + Variant 시각적 캡처 스킬
## Playwright MCP 기본 도구
```
playwright_navigate → URL 이동
playwright_screenshot → 현재 페이지 캡처 (path 지정 가능)
playwright_click → 요소 클릭
playwright_type → 텍스트 입력
playwright_scroll → 페이지 스크롤
playwright_wait → 로딩 대기
playwright_hover → 호버 상태
playwright_select → 드롭다운 선택
playwright_resize → 뷰포트 크기 변경
playwright_evaluate → JavaScript 실행
```
---
## Before 캡처 (현재 UI)
```
저장 경로: C:\GUARDiA\design-overhaul\before\
홈페이지:
→ navigate: https://zioinfo.co.kr
→ screenshot: before/home_main.png
→ navigate: https://zioinfo.co.kr/company/history
→ screenshot: before/home_history.png
→ navigate: https://zioinfo.co.kr/company/ci
→ screenshot: before/home_ci.png
→ navigate: https://zioinfo.co.kr/solution/guardia
→ screenshot: before/home_guardia.png
ITSM:
→ navigate: https://zioinfo.co.kr:8443
→ screenshot: before/itsm_login.png
→ [로그인: admin / Admin@2026!]
→ screenshot: before/itsm_dashboard.png
→ [SR 목록 클릭]
→ screenshot: before/itsm_sr_list.png
Manager:
→ navigate: https://zioinfo.co.kr:8090
→ [로그인]
→ screenshot: before/manager_dashboard.png
→ navigate: /scraping
→ screenshot: before/manager_scraping.png
```
---
## Variant 디자인 탐색 (variant.com/community)
이미 로그인 상태 → https://variant.com/community
```
# 대시보드 UI 레퍼런스
→ navigate: https://variant.com/community
→ screenshot: variant/community_main.png
→ [검색창에 입력]
→ type: "enterprise dashboard modern blue"
→ wait: 2000ms
→ screenshot: variant/dashboard_results.png
→ [첫 번째 결과 클릭 / 마음에 드는 것 선택]
→ screenshot: variant/dashboard_selected.png
# 홈페이지 레퍼런스
→ type: "corporate IT company landing page"
→ screenshot: variant/homepage_results.png
# 모바일 앱 레퍼런스
→ type: "mobile ITSM monitoring dark"
→ screenshot: variant/mobile_results.png
# 관리자 콘솔 레퍼런스
→ type: "admin console sidebar ncloud"
→ screenshot: variant/admin_results.png
```
---
## After 캡처 (개편 후)
```
저장 경로: C:\GUARDiA\design-overhaul\after\
반응형 3단계 캡처:
→ resize: {width: 1440, height: 900}
→ screenshot: after/home_1440.png
→ resize: {width: 768, height: 1024}
→ screenshot: after/home_768.png
→ resize: {width: 375, height: 812}
→ screenshot: after/home_375.png
```
---
## Before/After 비교 리포트 생성
```python
# Python으로 나란히 비교 이미지 생성
from PIL import Image
def side_by_side(before_path, after_path, out_path):
before = Image.open(before_path)
after = Image.open(after_path)
w = before.width + after.width + 20
h = max(before.height, after.height)
canvas = Image.new('RGB', (w, h), '#f1f5f9')
canvas.paste(before, (0, 0))
canvas.paste(after, (before.width + 20, 0))
canvas.save(out_path)
```
---
## 저장 구조
```
C:\GUARDiA\design-overhaul\
├── before/ ← 개편 전 스크린샷
│ ├── home_main.png
│ ├── itsm_dashboard.png
│ └── ...
├── variant/ ← Variant 레퍼런스
│ ├── dashboard_results.png
│ └── ...
├── after/ ← 개편 후 스크린샷
│ ├── home_1440.png
│ ├── home_768.png
│ └── ...
├── compare/ ← Before/After 비교
└── tokens/ ← 디자인 토큰 문서
```

185
.claude/skills/repo-split-orchestrator/SKILL.md
View File

@ -1,185 +0,0 @@
---
name: repo-split-orchestrator
description: "GUARDiA 모노레포를 4개 독립 Gitea 저장소로 분리하는 오케스트레이터. 로컬 소스 분리 → Gitea repo 생성/push → CI/CD webhook 연결 → 매뉴얼 업데이트의 전체 파이프라인을 실행한다. 다음 상황에서 반드시 사용: (1) '레파지토리 분리', '저장소 분리', 'repo 분리'; (2) 'GitHub 제거', 'Gitea만 사용'; (3) '각 시스템 독립 repo'; (4) 분리 후 webhook/CI/CD 연결; (5) 다시 실행, 업데이트, 보완."
---
# GUARDiA 레파지토리 분리 오케스트레이터
**실행 모드:** 파이프라인 (순차 서브 에이전트)
`repo-splitter` → `gitea-publisher` → `cicd-wirer` → `doc-updater`
---
## 분리 목표
```
현재 (모노레포) 목표 (독립 repo × 5)
C:\GUARDiA\workspace\ C:\GUARDiA\repos\
├── zioinfo-web/ → ├── zioinfo-web\ (zio/zioinfo-web)
├── guardia-itsm/ → ├── guardia-itsm\ (zio/guardia-itsm)
├── guardia-manager/ → ├── guardia-manager\ (zio/guardia-manager)
├── guardia-messenger/→ ├── guardia-messenger\ (zio/guardia-messenger)
└── guardia-docs/ → └── guardia-docs\ (zio/guardia-docs)
```
---
## Phase 0: 사전 확인
```bash
# 현재 모노레포 상태
cd C:\GUARDiA
git status # 커밋 안된 변경사항 없어야 함
git remote -v # origin(GitHub) + gitea + gitea-itsm 확인
# Gitea 서버 상태
curl http://101.79.17.164:3000 --head
```
⚠️ **주의사항:**
- 미커밋 변경사항이 있으면 먼저 커밋
- 분리 중 원본 모노레포 수정 금지
- `C:\GUARDiA\repos\` 디렉토리가 `.gitignore`에 추가됨
---
## Phase 1: 로컬 소스 분리 (repo-splitter)
```bash
cd C:\GUARDiA
# 1-1. repos 디렉토리 생성
mkdir -p C:\GUARDiA\repos
# 1-2. 각 서브트리 히스토리 분기
git subtree split --prefix=workspace/zioinfo-web -b split/zioinfo-web
git subtree split --prefix=workspace/guardia-itsm -b split/guardia-itsm
git subtree split --prefix=workspace/guardia-manager -b split/guardia-manager
git subtree split --prefix=workspace/guardia-messenger -b split/guardia-messenger
# 1-3. 각 독립 repo 디렉토리 생성 및 클론
for name in zioinfo-web guardia-itsm guardia-manager guardia-messenger; do
split_branch="split/$name"
target="C:/GUARDiA/repos/$name"
mkdir -p "$target"
git clone --no-local --branch "$split_branch" . "$target"
echo "Created: $target"
git -C "$target" log --oneline -3
done
# 1-4. manual/ → guardia-docs
git subtree split --prefix=workspace/guardia-docs -b split/guardia-docs
mkdir -p C:\GUARDiA\repos\guardia-docs
git clone --no-local --branch split/guardia-docs . C:\GUARDiA\repos\guardia-docs
# 1-5. repos/ 모노레포 .gitignore에 추가
echo "repos/" >> C:\GUARDiA\.gitignore
```
---
## Phase 2: Gitea 저장소 생성 + push (gitea-publisher)
```bash
# 2-1. 신규 저장소 생성 (manager, messenger, docs)
for repo in guardia-manager guardia-messenger guardia-docs; do
curl -sf -X POST http://101.79.17.164:3000/api/v1/user/repos \
-u 'zio:Zio@Admin2026!' \
-H 'Content-Type: application/json' \
-d "{\"name\":\"$repo\",\"private\":false,\"auto_init\":false}" \
&& echo "Created $repo"
done
# 2-2. 각 독립 repo에 Gitea remote 설정 + push
declare -A REPOS=(
[zioinfo-web]="zio/zioinfo-web"
[guardia-itsm]="zio/guardia-itsm"
[guardia-manager]="zio/guardia-manager"
[guardia-messenger]="zio/guardia-messenger"
[guardia-docs]="zio/guardia-docs"
)
for local_name in "${!REPOS[@]}"; do
repo_path="C:/GUARDiA/repos/$local_name"
gitea_url="http://zio:Zio%40Admin2026%21@101.79.17.164:3000/${REPOS[$local_name]}.git"
cd "$repo_path"
git remote add origin "$gitea_url"
git push origin main --force
echo "Pushed: $local_name → ${REPOS[$local_name]}"
done
# 2-3. 모노레포에서 GitHub(origin) remote 제거
cd C:\GUARDiA
git remote remove origin
git remote -v # gitea + gitea-itsm만 남아야 함
```
---
## Phase 3: CI/CD Webhook 연결 (cicd-wirer)
```bash
# 3-1. Gitea webhook 등록
REPOS_WITH_WEBHOOK=(zioinfo-web guardia-itsm guardia-manager guardia-messenger)
for repo in "${REPOS_WITH_WEBHOOK[@]}"; do
curl -sf -X POST "http://101.79.17.164:3000/api/v1/repos/zio/$repo/hooks" \
-u 'zio:Zio@Admin2026!' \
-H 'Content-Type: application/json' \
-d '{
"type":"gitea",
"config":{"url":"http://localhost:9999","content_type":"json","secret":"zioinfo-deploy-2026"},
"events":["push"],"active":true
}' \
&& echo "Webhook: $repo"
done
# 3-2. deploy_server.py repo name 매핑 업데이트 (서버에서)
# guardia-manager, guardia-messenger 배포 경로 추가
```
---
## Phase 4: 문서 업데이트 (doc-updater)
- 각 독립 repo에 `CLAUDE.md` 생성
- `manual/43_레파지토리_구조_가이드.md` 신규 작성
- `manual/20_zio서버_CICD_가이드.md` 업데이트
- `manual/42_zio서버_소프트웨어_구성도.md` 업데이트
---
## 에러 핸들링
| 오류 | 원인 | 해결 |
|------|------|------|
| subtree split 실패 | prefix 경로 오탈자 | `git log --oneline -- {prefix}` 확인 |
| Gitea push 413 | 파일 크기 초과 | `git lfs` 또는 대용량 파일 `.gitignore` 추가 |
| Gitea repo 이미 존재 | 중복 생성 시도 | 오류 무시하고 진행 (이미 있으면 OK) |
| webhook 미트리거 | 저장소명 불일치 | deploy_server.py의 repo name 매핑 확인 |
---
## 완료 검증 체크리스트
```
□ C:\GUARDiA\repos\ 아래 5개 디렉토리 존재
□ 각 repo git log 정상 (히스토리 있음)
□ Gitea에 5개 저장소 확인 가능
□ GitHub remote(origin) 제거됨
□ 각 repo에 Gitea remote만 존재
□ webhook 4개 등록 완료
□ 매뉴얼 43 신규 생성
□ CLAUDE.md 업데이트
```
---
## 테스트 시나리오
**정상 흐름:**
1. git subtree split → 각 브랜치 생성 확인
2. repos/ 디렉토리에 클론 → `git log` 히스토리 확인
3. Gitea push → 웹 브라우저에서 저장소 확인
4. test push → webhook 트리거 → 서버 배포 로그 확인
**에러 흐름:**
- split 브랜치 이미 존재 → 먼저 `git branch -D split/xxx` 후 재실행

191
.claude/skills/system-sync-orchestrator/SKILL.md
View File

@ -1,191 +0,0 @@
---
name: system-sync-orchestrator
description: >
GUARDiA 5개 시스템(guardia-itsm, zioinfo-web, guardia-manager, guardia-messenger, guardia-docs)
배포 상태를 검증하고 이슈를 자동 수정하는 오케스트레이터.
workspace ↔ repos ↔ Gitea ↔ 서버 4-way 동기화 불일치, /var/www 구버전,
서버 stash 잔존, app vs src 미동기화, uncommitted 변경을 탐지·수정한다.
다음 상황에서 반드시 사용:
(1) '5개 시스템 확인', '배포 상태 점검', '서버 최신 확인';
(2) '동기화', 'sync', '최신본 올려줘', '배포 맞춰줘';
(3) Manager/ITSM/홈페이지/Messenger/Docs 배포 이슈;
(4) 다시 실행, 업데이트, 수정, 보완.
---
# GUARDiA 5개 시스템 배포 동기화 오케스트레이터
**실행 모드:** 하이브리드
- Phase 1 (검증): 서브 에이전트 (deploy-verifier)
- Phase 2 (수정): 에이전트 팀 (deploy-verifier + deploy-fixer 협업)
- Phase 3 (재검증): 서브 에이전트
---
## Phase 0: 컨텍스트 확인
```
_workspace/ 존재 여부 확인:
- 없음 → 초기 실행 (Phase 1부터)
- 있음 + 사용자가 특정 시스템만 지정 → 부분 재실행 (해당 시스템만)
- 있음 + 전체 재검증 요청 → 전체 재실행
```
`_workspace/` 디렉토리:
```
C:/GUARDiA/.claude/agents/_workspace/
├── verify_report.json ← deploy-verifier 출력
└── fix_report.json ← deploy-fixer 출력
```
---
## Phase 1: 전체 검증 (서브 에이전트)
**deploy-verifier** 서브 에이전트로 실행:
### 5개 시스템 검증 항목
| 시스템 | 서비스 | 경로 | 정적 경로 |
|--------|--------|------|-----------|
| guardia-itsm | `guardia` | `/opt/guardia/src` + `/opt/guardia/app` | — |
| zioinfo-web | `zioinfo` | `/opt/zioinfo/src` | `/var/www/zioinfo` |
| guardia-manager | `guardia-manager` | `/opt/manager/src` or `/opt/manager/backend` | `/var/www/manager` |
| guardia-messenger | EAS 빌드 | Gitea only | — |
| guardia-docs | — | Gitea only | `/var/www/docs` (선택) |
### 검증 스크립트 패턴
`C:/GUARDiA/scripts/check/verify_all_systems.py` 참조.
Gitea API 인증: `base64.b64encode(b'zio:Zio@Admin2026!').decode()`
### 이슈 분류
| 코드 | 설명 | 심각도 |
|------|------|--------|
| `STALE_WWW` | /var/www 파일이 최근 배포보다 오래됨 | critical |
| `APP_SRC_DRIFT` | /opt/{app}/app vs src 미동기화 | critical |
| `STASH_EXISTS` | 서버 git stash 잔존 | warning |
| `UNCOMMITTED` | 비빌드 파일 uncommitted | warning |
| `COMMIT_MISMATCH` | 서버 커밋 != Gitea 커밋 | critical |
| `SERVICE_DOWN` | systemctl not active | critical |
| `WORKSPACE_DRIFT` | workspace != repos | info |
---
## Phase 2: 이슈 수정 (에이전트 팀)
Phase 1에서 이슈가 없으면 → 완료 보고 후 종료.
이슈 있으면 → deploy-fixer와 팀 구성.
### 수정 우선순위
```
1. SERVICE_DOWN → 서비스 재기동 먼저
2. APP_SRC_DRIFT → rsync + restart
3. STASH_EXISTS → stash 내용 평가 → 복원 또는 삭제
4. COMMIT_MISMATCH → git fetch + reset --hard origin/main
5. STALE_WWW → npm/mvn 빌드 + www 복사
6. UNCOMMITTED → 파일 분류 (중요/임시) → workspace 반영 또는 clean
7. WORKSPACE_DRIFT → sync_workspace_to_repos.py 실행
```
### 시스템별 수정 처리
**guardia-itsm (APP_SRC_DRIFT 표준 처리):**
```bash
rsync -a --exclude=__pycache__ --exclude=.git \
--exclude="*.db" --exclude="uploads" \
/opt/guardia/src/ /opt/guardia/app/
systemctl restart guardia
sleep 4 && systemctl is-active guardia
```
**zioinfo-web (STALE_WWW 표준 처리):**
```bash
cd /opt/zioinfo/src
git fetch origin main && git reset --hard origin/main
# stash 있으면 핵심 파일 cherry-pick
cd frontend && npm run build
cp -r ../backend/src/main/resources/static/. /var/www/zioinfo/
systemctl restart zioinfo
```
**guardia-manager (STALE_WWW 표준 처리):**
```bash
cd /opt/manager/src/frontend # or /opt/manager/backend
# workspace/guardia-manager의 최신 frontend를 서버에 업로드
npm ci && npm run build
cp -r dist/. /var/www/manager/
systemctl restart guardia-manager
```
**stash 처리 원칙:**
- `git stash show --stat` 으로 변경 파일 목록 확인
- `frontend/src/` 파일 포함 → `git checkout stash -- frontend/src/` 로 선별 복원 후 빌드
- 빌드 산출물(`static/assets/`)만 있으면 → `git stash drop`
---
## Phase 3: 재검증 (서브 에이전트)
Phase 2 완료 후 deploy-verifier 재실행.
모든 `action_required` 항목이 비어있으면 성공.
---
## 결과 보고 형식
```
=== GUARDiA 5개 시스템 배포 상태 ===
✅ guardia-itsm — active | 커밋 일치 | app 동기화
✅ zioinfo-web — active | 커밋 일치 | www Jun 1 최신
✅ guardia-manager— active | 커밋 일치 | www Jun 1 최신
✅ guardia-messenger — EAS v1.0.0 | Gitea 최신
✅ guardia-docs — 36개 md | Gitea 최신
수정된 이슈: X개
남은 이슈: 0개
```
---
## 에러 핸들링
| 에러 | 처리 |
|------|------|
| 서비스 재기동 실패 | `journalctl -u {service} -n 20` 로그 수집 후 보고 |
| npm build 실패 | `node_modules` 삭제 후 `npm ci` 재시도 |
| git reset 충돌 | `git clean -fd` 후 재시도 |
| Gitea push 실패 | bundle → 서버 → push 방식 (push_jenkinsfiles_api 패턴) |
| rsync 권한 오류 | `chown -R root:root /opt/{app}` 후 재시도 |
---
## 테스트 시나리오
**정상 흐름:**
1. 검증 실행 → 이슈 탐지 (Manager STALE_WWW, ITSM APP_SRC_DRIFT)
2. 수정 팀 실행 → Manager npm build, ITSM rsync
3. 재검증 → 모두 ✅
**에러 흐름:**
- Manager npm build 실패 → `npm ci` 재시도 → 실패 시 보고서에 기록 후 다음 시스템 진행
---
## should-trigger
- "5개 시스템 배포 확인해줘"
- "서버에 최신본 올라간 거 맞아?"
- "Manager 구버전 올라가 있는데 수정해줘"
- "guardia-itsm 배포 상태 점검"
- "홈페이지 최신 코드 반영됐나?"
- "전체 동기화 해줘"
- "다시 실행", "수정", "보완"
## should-NOT-trigger
- "guardia-itsm 새 기능 만들어줘" → itsm-dev 에이전트
- "홈페이지 디자인 바꿔줘" → ui-overhaul-orchestrator
- "Jenkins 파이프라인 설정" → cicd-pipeline-orchestrator
- "코드 리뷰해줘" → code-review 스킬

147
.claude/skills/system-sync-orchestrator/references/verify-script.py
View File

@ -1,147 +0,0 @@
"""
deploy-verifier 에이전트가 사용하는 5개 시스템 검증 스크립트.
verify_all_systems.py 기반으로 JSON 보고서를 출력한다.
"""
import paramiko, sys, json, base64, os
from datetime import datetime
sys.stdout.reconfigure(encoding='utf-8', errors='replace')
c = paramiko.SSHClient()
c.set_missing_host_key_policy(paramiko.AutoAddPolicy())
c.connect('101.79.17.164', username='root', password='1q2w3e!Q', timeout=15)
G = base64.b64encode(b'zio:Zio@Admin2026!').decode()
def ssh(cmd, timeout=15):
_, o, _ = c.exec_command(cmd, timeout=timeout)
return o.read().decode('utf-8', 'replace').strip()
def gitea_commit(repo):
out = ssh(f"curl -sf 'http://127.0.0.1:9003/api/v1/repos/zio/{repo}/commits?limit=1' "
f"-H 'Authorization: Basic {G}' 2>/dev/null | "
"python3 -c \"import sys,json; d=json.load(sys.stdin); "
"c=d[0]; print(c['sha'][:8]+'|'+c['commit']['message'][:50])\" 2>/dev/null")
return out.split('|') if '|' in out else ['unknown', 'unknown']
report = {
"timestamp": datetime.now().isoformat(),
"systems": {},
"action_required": [],
"critical": [],
"warnings": [],
}
SYSTEMS = {
"guardia-itsm": {
"service": "guardia",
"src_path": "/opt/guardia/src",
"app_path": "/opt/guardia/app",
"www_path": None,
"port": "9001",
},
"zioinfo-web": {
"service": "zioinfo",
"src_path": "/opt/zioinfo/src",
"app_path": None,
"www_path": "/var/www/zioinfo",
"port": "8082",
},
"guardia-manager": {
"service": "guardia-manager",
"src_path": "/opt/manager/backend",
"app_path": None,
"www_path": "/var/www/manager",
"port": "8090",
},
"guardia-messenger": {
"service": None,
"src_path": None,
"app_path": None,
"www_path": None,
"port": None,
},
"guardia-docs": {
"service": None,
"src_path": None,
"app_path": None,
"www_path": "/var/www/docs",
"port": None,
},
}
for name, cfg in SYSTEMS.items():
issues = []
info = {"issues": [], "status": {}}
# 서비스 상태
if cfg["service"]:
svc = ssh(f'systemctl is-active {cfg["service"]} 2>/dev/null')
info["status"]["service"] = svc
if svc != "active":
issues.append(f"SERVICE_DOWN:{cfg['service']}")
report["critical"].append(f"{name}: service not active")
# 서버 커밋
if cfg["src_path"]:
src_commit = ssh(f'git -C {cfg["src_path"]} log -1 --format="%H|%s" 2>/dev/null')
info["status"]["server_commit"] = src_commit[:8] if src_commit else "none"
# Gitea 커밋
g_sha, g_msg = gitea_commit(name)
info["status"]["gitea_commit"] = g_sha
if src_commit and g_sha != "unknown":
if not src_commit.startswith(g_sha):
issues.append(f"COMMIT_MISMATCH:server={src_commit[:8]} gitea={g_sha}")
report["critical"].append(f"{name}: commit mismatch")
# stash 확인
stash = ssh(f'git -C {cfg["src_path"]} stash list 2>/dev/null')
if stash:
issues.append(f"STASH_EXISTS:{stash[:80]}")
report["warnings"].append(f"{name}: stash exists")
# uncommitted 확인 (빌드 산출물 제외)
uncommit = ssh(f'git -C {cfg["src_path"]} status --short 2>/dev/null | '
"grep -v 'static/assets/' | grep -v '.pyc' | grep -v '__pycache__'")
if uncommit:
issues.append(f"UNCOMMITTED:{uncommit[:120]}")
report["warnings"].append(f"{name}: uncommitted changes")
# app vs src 비교 (ITSM)
if cfg["app_path"] and cfg["src_path"]:
diff = ssh(f'diff -rq {cfg["src_path"]} {cfg["app_path"]} '
'--exclude="*.pyc" --exclude="__pycache__" --exclude=".git" '
'--exclude="*.db" --exclude="uploads" --exclude=".env" '
'--exclude=".pytest_cache" 2>/dev/null | head -5')
if diff:
issues.append(f"APP_SRC_DRIFT:{diff[:150]}")
report["critical"].append(f"{name}: app/src drift")
# /var/www 날짜 확인
if cfg["www_path"]:
www_date = ssh(f'stat {cfg["www_path"]}/index.html 2>/dev/null | grep Modify | cut -d" " -f2,3 || echo "missing"')
info["status"]["www_date"] = www_date
# 오늘 날짜(Jun 1 = 2026-06-01) 또는 최근 3일 이내면 최신으로 간주
import re as _re
today_str = __import__('datetime').datetime.now().strftime('%Y-%m-%d')
is_recent = (today_str in www_date or
"Jun 1" in www_date or "Jun 1" in www_date or
"missing" in www_date or not www_date.strip())
if not is_recent and www_date.strip():
issues.append(f"STALE_WWW:{www_date}")
report["critical"].append(f"{name}: stale www ({www_date})")
info["issues"] = issues
report["systems"][name] = info
if issues:
report["action_required"].append(name)
c.close()
# 저장
os.makedirs("C:/GUARDiA/.claude/agents/_workspace", exist_ok=True)
with open("C:/GUARDiA/.claude/agents/_workspace/verify_report.json", "w", encoding="utf-8") as f:
json.dump(report, f, ensure_ascii=False, indent=2)
print(json.dumps(report, ensure_ascii=False, indent=2))

50
.claude/skills/test-orchestrator/SKILL.md
View File

@ -1,50 +0,0 @@
---
name: test-orchestrator
description: "GUARDiA 단위·통합 테스트 오케스트레이터. pytest(ITSM), httpx E2E(API), 홈페이지 응답 검증을 자동 실행하고 결과를 보고한다. 다음 상황에서 반드시 사용: (1) '테스트 실행', '테스트 해줘'; (2) '단위 테스트', '통합 테스트'; (3) CI/CD 파이프라인 테스트 단계; (4) 다시 실행, 업데이트, 보완."
---
# GUARDiA 테스트 오케스트레이터
**실행 모드:** 병렬 서브 에이전트 (단위 + 통합 동시 실행)
## 테스트 구조
```
tests/
├── unit/
│ ├── test_models.py ← Pydantic 스키마 검증
│ ├── test_rpa_engine.py ← RPA Validator 단위 테스트
│ └── test_nl_command.py ← NL 명령 파서 단위 테스트
└── integration/
├── test_auth_api.py ← 로그인/JWT 검증
├── test_itsm_api.py ← SR/CMDB/대시보드 API
├── test_rpa_api.py ← RPA 엔드포인트
└── test_homepage.py ← 홈페이지 응답
```
## Phase 1: 단위 테스트 (서버)
```bash
cd /opt/guardia/app
/opt/guardia/venv/bin/pytest tests/unit/ \
-q --tb=short \
--junitxml=/tmp/unit-results.xml
```
## Phase 2: 통합 테스트 (서버 API)
```bash
cd /opt/guardia/app
/opt/guardia/venv/bin/pytest tests/integration/ \
-q --tb=short \
--junitxml=/tmp/integration-results.xml
```
## 테스트 결과 보고
```
=== 테스트 결과 요약 ===
단위 테스트: PASS 12 / FAIL 0 / SKIP 2
통합 테스트: PASS 8 / FAIL 1 / SKIP 0
전체: PASS 20 / FAIL 1
```

170
.claude/skills/ui-overhaul-orchestrator/SKILL.md
View File

@ -1,170 +0,0 @@
---
name: ui-overhaul-orchestrator
description: "zio 전체 시스템(홈페이지·ITSM·Manager·Messenger) UI 전면 개편 오케스트레이터. Playwright MCP로 현재 UI 캡처 → Variant에서 디자인 레퍼런스 수집 → 통합 디자인 토큰 설계 → 시스템별 컴포넌트 리팩토링 → Before/After 시각적 QA를 파이프라인으로 조율한다. 다음 상황에서 반드시 사용: (1) 'UI 전면 개편', '디자인 개편', '전체 디자인 바꿔줘'; (2) 'Variant에서 디자인 찾아서 적용', 'tokens.css 만들어줘'; (3) '홈페이지/ITSM/Manager/Messenger 디자인 현대화'; (4) 'Before/After 비교', '시각적 QA'; (5) 다시 실행, 업데이트, 수정, 보완."
---
# zio UI 전면 개편 오케스트레이터
**문서 참조:** `manual/99. 디자인 전면 개편.md`
**실행 모드:** 파이프라인 — ui-scout → design-system-architect → component-refactor-engineer → visual-qa-tester
---
## Phase 0: 컨텍스트 확인
```
design-overhaul/ 폴더 존재 여부 확인
├── before/ 있음 → Phase 2부터 (캡처 완료)
├── tokens/ 있음 → Phase 3부터 (토큰 완료)
├── after/ 있음 → Phase 4만 (QA 단계)
└── 없음 → Phase 1부터 전체 실행
```
---
## Phase 1: 현황 캡처 (ui-scout + playwright-visual-capture 스킬)
**실행 모드: 서브 에이전트**
```
[ui-scout]
1. Playwright MCP → 4개 시스템 Before 스크린샷
- https://zioinfo.co.kr (홈페이지 6개 페이지)
- https://zioinfo.co.kr:8443 (ITSM 5개 화면)
- https://zioinfo.co.kr:8090 (Manager 4개 화면)
- 모바일: 375px 반응형
2. Playwright MCP → Variant 탐색
- navigate: https://variant.com/community (이미 로그인)
- 키워드별 디자인 옵션 캡처:
· "enterprise dashboard modern"
· "corporate IT landing page"
· "admin console sidebar"
· "mobile monitoring app"
3. 개편 방향 도출 → design-system-architect에게 전달
```
저장: `C:\GUARDiA\design-overhaul\before\` + `variant\`
---
## Phase 2: 디자인 토큰 설계 (design-system-architect + design-token-system 스킬)
**실행 모드: 서브 에이전트**
```
[design-system-architect]
1. Variant 레퍼런스에서 색상·타이포·간격 추출
2. zio 브랜드 색상 (#0051A2, #00A3E0) 반영
3. tokens.css 생성 → 4개 시스템 공통
산출물:
- workspace/zioinfo-web/frontend/src/styles/tokens.css
- itsm/static/tokens.css
- manager/frontend/src/styles/tokens.css
- app/constants/tokens.ts
```
---
## Phase 3: 컴포넌트 리팩토링 (component-refactor-engineer + component-refactor 스킬)
**실행 모드: 에이전트 팀 (4개 시스템 병렬)**
```
[component-refactor-engineer × 4 — 병렬]
홈페이지 담당:
- tokens.css import 추가 (global.css)
- Header.jsx 현대화 (고정 헤더 + 블러 배경)
- Hero 섹션 재설계 (그라디언트 + 애니메이션)
- 카드·버튼·폼 토큰 적용
- Company.jsx 타임라인 개선
ITSM 담당:
- tokens.css → style.css @import
- 사이드바 아이콘+텍스트 슬라이드 애니메이션
- 대시보드 카드 그림자·반경 토큰 적용
- 테이블 호버·정렬 UX 개선
Manager 담당:
- tokens.css 통합
- Sidebar.tsx 활성 상태 + 그룹 헤더
- StatCard.tsx 변화율·아이콘 추가
- Dashboard.tsx 차트 색상 토큰화
Messenger 담당:
- tokens.ts 생성
- components/ui/ 폴더: Button, Card, Badge
- 탭바 아이콘 filled/outlined 교체
- 대시보드 카드 레이아웃
```
---
## Phase 4: 시각적 QA (visual-qa-tester + playwright-visual-capture 스킬)
**실행 모드: 서브 에이전트**
```
[visual-qa-tester]
1. After 스크린샷 캡처 (Playwright MCP)
- 1440px / 768px / 375px 반응형 3단계
2. Before vs After 나란히 비교 이미지 생성
3. 디자인 토큰 준수 검증
4. 이슈 발견 → component-refactor-engineer에게 수정 요청
5. QA 리포트 생성 → manual/ 폴더 저장
```
저장: `C:\GUARDiA\design-overhaul\after\` + `compare\`
---
## Phase 5: 배포
```
홈페이지:
python C:\GUARDiA\deploy_full.py
ITSM:
paramiko SSH → rsync itsm/static/ → systemctl restart guardia
Manager:
npm run build → sftp upload → systemctl restart guardia-manager
```
---
## 시스템별 개편 우선순위
| 순위 | 시스템 | 핵심 페이지 | 예상 공수 |
|------|--------|------------|---------|
| 1 | 홈페이지 | 메인·GUARDiA 소개·연혁 | 1일 |
| 2 | ITSM | 대시보드·사이드바·SR목록 | 1일 |
| 3 | Manager | 대시보드·사이드바 | 0.5일 |
| 4 | Messenger | 탭바·대시보드·카드 | 1일 |
---
## 테스트 시나리오
**정상:** Variant 탐색 → 토큰 확정 → 홈페이지 Before/After 비교 → 배포
**에러:** 개편 후 반응형 깨짐 → 375px 스크린샷 확인 → CSS 수정 → 재캡처
---
## should-trigger
- "홈페이지 UI 전면 개편해줘"
- "Variant에서 디자인 찾아서 적용해줘"
- "4개 시스템 디자인 통일해줘"
- "tokens.css 만들고 전체 적용해줘"
- "Before After 비교 스크린샷 찍어줘"
- "버튼/카드 스타일 통일해줘"
## should-NOT-trigger
- "새 기능 추가" → guardia-orchestrator
- "배포만 해줘" → deploy-pipeline
- "색상 하나만 바꿔줘" → 직접 편집

245
.claude/skills/upstage-ocr-orchestrator/SKILL.md
View File

@ -1,245 +0,0 @@
---
name: upstage-ocr-orchestrator
description: >
Upstage Document AI OCR 연동 및 GUARDiA ITSM 워크플로우 자동화 오케스트레이터.
Upstage API(Document Parse, Information Extraction, Document QA)를 연동하여
계약서·납품서·청구서·장애보고서·감사보고서 등을 자동 처리한다.
현대백화점 같은 기업 브랜드 계약서를 포함한 일반 계약서도 처리한다.
처리 결과를 ITSM 기능(조달관리·CMDB·과금·CSAP·SR)에 자동 연동한다.
다음 상황에서 반드시 사용:
(1) 'OCR', 'Upstage', '문서 파싱', '문서 자동 처리', '계약서 OCR';
(2) '납품서 CMDB 등록', '청구서 자동 파싱', '계약서 자동 등록';
(3) '현대백화점 계약', '브랜드 계약서', '일반 계약서 처리';
(4) '장애보고서 이미지 → SR', '회의록 → 액션아이템';
(5) 'CSAP 보고서 자동 업데이트', '감사 문서 처리';
(6) 다시 실행, 업데이트, 수정, 보완.
---
# Upstage OCR 연동 오케스트레이터
**실행 모드:** 에이전트 팀
- 팀 구성: upstage-ocr-dev (OCR 엔진) + ocr-workflow-dev (ITSM 연동)
- Phase 1: OCR 엔진 구현
- Phase 2: 워크플로우 구현 (병렬)
- Phase 3: DB 모델 + main.py 등록
---
## 시스템 개요
```
사용자/시스템
↓ 문서 업로드 (PDF/PNG/JPG)
upstage_ocr.py
↓ Upstage API 호출
├── Document Parse → 구조화 JSON (레이아웃/텍스트/테이블)
├── Information Extraction → Key-Value (스키마 기반)
└── Document QA → 자연어 답변
doc_workflow.py
↓ 결과 → ITSM 자동 연동
├── 계약서 → e_procurement.py (ProcurementRecord)
├── 납품서 → cmdb.py (Server 등록)
├── 청구서 → billing.py (Invoice)
├── 감사보고서 → compliance.py (CSAP 업데이트)
├── 장애보고서 → tasks.py (SR 생성)
├── 회의록 → tasks.py (SR + 작업)
└── 브랜드 계약서 → ProcurementRecord
```
---
## Phase 0: 컨텍스트 확인
```
_workspace/ 없음 → 초기 구현
있음 + OCR 엔진만 → upstage-ocr-dev 재실행
있음 + 워크플로우만 → ocr-workflow-dev 재실행
```
---
## Phase 1: OCR 엔진 구현 (upstage-ocr-dev)
### 구현 파일: `workspace/guardia-itsm/routers/upstage_ocr.py`
**핵심 구현:**
```python
UPSTAGE_BASE = "https://api.upstage.ai/v1/document-ai"
# 지원 형식
SUPPORTED_MIME = {
".pdf": "application/pdf",
".png": "image/png",
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".tiff": "image/tiff",
".bmp": "image/bmp",
".heic": "image/heic",
}
# 민감 정보 마스킹 패턴
SENSITIVE_PATTERNS = [
(r'\d{6}-[1-4]\d{6}', '######-#######'), # 주민번호
(r'\d{3}-\d{2}-\d{5}', '###-##-#####'), # 사업자번호 (보존)
(r'\d{3,4}-\d{4}-\d{4}', '****-****-****'), # 전화번호 뒷자리
]
```
**엔드포인트:**
| 엔드포인트 | 설명 |
|-----------|------|
| `POST /api/ocr/config` | Upstage API Key 저장 (AES-256-GCM) |
| `GET /api/ocr/config` | 설정 조회 (키 마스킹) |
| `POST /api/ocr/parse` | 문서 파싱 → 구조화 JSON |
| `POST /api/ocr/extract` | 정보 추출 → Key-Value |
| `POST /api/ocr/qa` | 문서 QA → 자연어 답변 |
| `POST /api/ocr/batch` | 다중 파일 배치 처리 |
| `GET /api/ocr/history` | 처리 이력 |
| `GET /api/ocr/usage` | API 사용량 |
---
## Phase 2: 워크플로우 구현 (ocr-workflow-dev)
### 구현 파일 1: `workspace/guardia-itsm/routers/doc_workflow.py`
| 엔드포인트 | 워크플로우 | 연동 |
|-----------|---------|------|
| `POST /api/docflow/contract` | 나라장터 계약서 | e_procurement.py |
| `POST /api/docflow/server-spec` | 서버납품서 | cmdb.py |
| `POST /api/docflow/invoice` | 청구서/세금계산서 | billing.py |
| `POST /api/docflow/audit-report` | 감사·CSAP 보고서 | compliance.py |
| `POST /api/docflow/incident-report` | 장애보고서 이미지 | tasks.py (SR) |
| `POST /api/docflow/meeting-minutes` | 회의록 | tasks.py (SR+작업) |
| `POST /api/docflow/brand-contract` | **기업 브랜드 계약서** | ProcurementRecord |
| `GET /api/docflow/jobs` | 작업 목록 | — |
| `GET /api/docflow/jobs/{id}` | 작업 상세 | — |
#### 브랜드 계약서 처리 (현대백화점 등)
```python
BRAND_CONTRACT_SCHEMA = {
"contract_title": "계약서 제목",
"party_a": "갑(발주사/브랜드사)",
"party_b": "을(수주사/공급사)",
"contract_amount": "계약금액",
"currency": "통화",
"contract_period": "계약기간",
"effective_date": "계약일",
"expiry_date": "만료일",
"payment_terms": "지급조건",
"contract_items": "계약품목/서비스",
"royalty_rate": "수수료율/로열티",
"territory": "적용지역",
"exclusive": "독점여부",
"renewal_clause": "갱신조항",
"termination": "해지조건",
"penalty_clause": "위약금",
"contact_a": "갑 담당자",
"contact_b": "을 담당자",
"special_terms": "특약사항",
}
```
### 구현 파일 2: `workspace/guardia-itsm/routers/doc_template.py`
내장 템플릿 + 커스텀 템플릿 관리
**내장 템플릿 7종:**
1. `narasajang_contract` — 나라장터 계약서
2. `server_delivery` — 서버 납품 명세서
3. `brand_contract` — 기업 브랜드 계약서 (현대백화점 등)
4. `invoice` — 세금계산서/청구서
5. `incident_report` — 장애 보고서
6. `csap_report` — CSAP 점검 보고서
7. `meeting_minutes` — 회의록
---
## Phase 3: DB 모델 + main.py 등록
```python
# 신규 모델
class UpstageOCRConfig(Base): ... # API Key 설정
class OCRHistory(Base): ... # 처리 이력
class DocWorkflowJob(Base): ... # 워크플로우 작업
class DocTemplate(Base): ... # 추출 템플릿
# main.py 등록
from routers import upstage_ocr, doc_workflow, doc_template
app.include_router(upstage_ocr.router)
app.include_router(doc_workflow.router)
app.include_router(doc_template.router)
```
---
## ITSM 사이드바 메뉴 추가
```javascript
// index.html에 추가
{ label: '문서 AI (OCR)', icon: '📄', children: [
{ nav: 'ocr_parse', label: 'Upstage OCR 파싱' },
{ nav: 'ocr_contract', label: '계약서 자동 처리' },
{ nav: 'ocr_invoice', label: '청구서 처리' },
{ nav: 'ocr_history', label: 'OCR 처리 이력' },
{ nav: 'doc_templates', label: '추출 템플릿 관리' },
]}
```
---
## 데이터 흐름
```
_workspace/
├── ocr_api_spec.md ← upstage-ocr-dev
└── workflow_spec.md ← ocr-workflow-dev
```
---
## 에러 핸들링
| 에러 | 처리 |
|------|------|
| Upstage API Key 없음 | 설정 페이지 안내 |
| API 한도 초과 | 큐잉 후 재시도 |
| 지원 안 되는 파일 형식 | 400 오류 + 지원 형식 안내 |
| 추출 실패 (낮은 신뢰도) | 수동 검토 큐 등록 + SR 생성 |
| 민감 정보 감지 | 자동 마스킹 후 처리 |
| 파일 크기 초과 | 20MB 한도 안내 |
---
## 테스트 시나리오
**정상 흐름 (브랜드 계약서):**
1. POST /api/docflow/brand-contract + 현대백화점_계약서.pdf
2. Upstage Extract API 호출 → 계약번호, 금액, 기간 추출
3. ProcurementRecord 자동 생성
4. 응답: {"ok": true, "contract_no": "HDC-2026-001", "amount": 50000000, ...}
**정상 흐름 (장애보고서 이미지):**
1. POST /api/docflow/incident-report + 장애화면.png
2. Upstage Document Parse → 에러 텍스트 추출
3. SR 자동 생성 (category=INCIDENT, priority=HIGH)
4. 응답: {"ok": true, "sr_id": 1234}
---
## should-trigger
- "OCR 연동", "Upstage 설정", "문서 파싱"
- "계약서 자동 등록", "현대백화점 계약", "브랜드 계약서"
- "납품서 CMDB 등록", "청구서 자동 처리"
- "장애보고서 이미지 SR", "회의록 액션아이템"
- "다시 실행", "수정", "보완"
## should-NOT-trigger
- "multimodal 이미지 분석" → multimodal.py (온프레미스)
- "SR 처리" → guardia-orchestrator
- "CMDB 관리" → cmdb.py 직접

305
.claude/skills/upstage-ocr-orchestrator/references/upstage-api-guide.md
View File

@ -1,305 +0,0 @@
# Upstage Document AI API 가이드
## 기본 정보
| 항목 | 값 |
|------|-----|
| Base URL | `https://api.upstage.ai/v1/document-ai` |
| 인증 | Bearer Token (API Key) |
| 최대 파일 크기 | 20MB |
| 지원 형식 | PDF, PNG, JPG, JPEG, TIFF, BMP, HEIC |
| 최대 페이지 | 100페이지/요청 |
---
## 1. Document Parse (문서 파싱)
### 요청
```http
POST https://api.upstage.ai/v1/document-ai/document-digitization
Authorization: Bearer {API_KEY}
Content-Type: multipart/form-data
document: (파일 바이너리)
model: document-parse # 텍스트 레이어 있는 PDF
document-parse-ocr # 이미지/스캔 PDF
ocr: auto # auto: 자동 판단
output_formats: ["text", "html", "markdown"]
```
### 응답 구조
```json
{
"api": "2.0",
"model": "document-parse",
"usage": {"pages": 3, "tokens": 1200},
"content": {
"markdown": "# 계약서\n\n...",
"html": "<html>...</html>",
"text": "계약서\n\n당사는 ..."
},
"elements": [
{
"category": "paragraph", // paragraph | table | figure | header | footer
"content": {"markdown": "...", "html": "...", "text": "..."},
"coordinates": [{"x": 0.1, "y": 0.1, "w": 0.8, "h": 0.05}],
"page": 1
},
{
"category": "table",
"content": {"markdown": "| 항목 | 금액 |\n|---|---|\n...", "html": "<table>...</table>"},
"page": 2
}
],
"pages": [{"page": 1, "width": 595, "height": 842}]
}
```
---
## 2. Information Extraction (정보 추출)
### 요청
```http
POST https://api.upstage.ai/v1/document-ai/information-extraction
Authorization: Bearer {API_KEY}
Content-Type: multipart/form-data
document: (파일 바이너리)
schema: {
"contract_no": "계약번호",
"amount": "계약금액",
"supplier": "공급사명"
}
```
### 응답 구조
```json
{
"api": "2.0",
"usage": {"pages": 1, "tokens": 800},
"result": {
"contract_no": {
"value": "2026-IT-0042",
"confidence": 0.97,
"coordinates": {"x": 0.2, "y": 0.15, "page": 1}
},
"amount": {
"value": "₩50,000,000",
"confidence": 0.95,
"normalized": 50000000
},
"supplier": {
"value": "(주)지오정보기술",
"confidence": 0.98
}
}
}
```
---
## 3. Document QA (문서 질의응답)
### 요청
```http
POST https://api.upstage.ai/v1/document-ai/document-qa
Authorization: Bearer {API_KEY}
Content-Type: multipart/form-data
document: (파일 바이너리)
question: "이 계약서의 계약 기간은 언제까지인가요?"
```
### 응답
```json
{
"answer": "본 계약의 계약기간은 2026년 6월 1일부터 2027년 5월 31일까지입니다.",
"confidence": 0.93,
"source": {"page": 2, "text": "제3조 (계약기간) 본 계약의 기간은..."}
}
```
---
## 활용 시나리오별 스키마
### 나라장터 계약서
```json
{
"contract_no": "계약번호",
"contract_name": "계약품명",
"supplier": "공급사명",
"supplier_biz_no":"사업자등록번호",
"amount": "계약금액(원)",
"vat": "부가세",
"start_date": "계약시작일(YYYY-MM-DD)",
"end_date": "계약종료일(YYYY-MM-DD)",
"institution": "발주기관명",
"manager": "담당자",
"payment_terms": "납부조건"
}
```
### 서버 납품 명세서
```json
{
"hostname": "호스트명/서버명",
"manufacturer": "제조사",
"model_no": "모델번호",
"serial_no": "시리얼번호",
"cpu_model": "CPU 모델",
"cpu_cores": "CPU 코어 수",
"memory_gb": "메모리 용량(GB)",
"disk_config": "스토리지 구성",
"os": "운영체제",
"ip_addr": "IP주소",
"rack_location": "랙 위치",
"warranty_until": "보증기간 만료일",
"delivery_date": "납품일"
}
```
### 기업 브랜드 계약서 (현대백화점 등)
```json
{
"contract_title": "계약서 제목",
"party_a": "갑(브랜드사/발주사)",
"party_a_biz_no": "갑 사업자번호",
"party_b": "을(공급사/입점사)",
"party_b_biz_no": "을 사업자번호",
"contract_amount": "계약금액",
"currency": "통화(KRW/USD)",
"effective_date": "계약일",
"expiry_date": "만료일",
"auto_renewal": "자동갱신여부",
"payment_terms": "지급조건",
"contract_items": "계약품목/서비스",
"royalty_rate": "수수료율",
"territory": "적용지역/매장",
"exclusive": "독점여부",
"termination": "해지조건",
"penalty_clause": "위약금",
"special_terms": "특약사항",
"contact_a": "갑 담당자",
"contact_b": "을 담당자"
}
```
### 세금계산서/청구서
```json
{
"invoice_no": "세금계산서번호/청구번호",
"issue_date": "발행일",
"supplier_name": "공급자 상호",
"supplier_biz_no": "공급자 사업자번호",
"buyer_name": "공급받는자 상호",
"buyer_biz_no": "공급받는자 사업자번호",
"supply_amount": "공급가액",
"vat_amount": "세액",
"total_amount": "합계금액",
"items": "품목/내역",
"payment_due": "결제기한",
"bank_account": "입금계좌(마스킹)"
}
```
### 장애 보고서
```json
{
"incident_date": "발생일시",
"incident_type": "장애유형",
"affected_system": "영향 시스템",
"error_message": "오류 메시지",
"root_cause": "근본원인",
"impact_scope": "영향 범위",
"resolution": "조치사항",
"downtime_minutes": "다운타임(분)",
"reporter": "보고자"
}
```
### CSAP 점검 보고서
```json
{
"institution": "기관명",
"check_date": "점검일",
"total_items": "총 점검항목 수",
"passed_items": "적합 항목 수",
"failed_items": "부적합 항목 수",
"compliance_rate": "준수율(%)",
"major_findings": "주요 발견사항",
"recommendations": "권고사항"
}
```
### 회의록
```json
{
"meeting_date": "회의일시",
"meeting_place": "장소",
"participants": "참석자",
"agenda": "안건",
"decisions": "결정사항",
"action_items": "액션아이템(담당자/기한)",
"next_meeting": "차기 회의일"
}
```
---
## 비용 가이드 (참고)
| API | 페이지당 비용 |
|-----|------------|
| Document Parse | ~$0.01/페이지 |
| Information Extraction | ~$0.02/페이지 |
| Document QA | ~$0.02/요청 |
> 최신 요금은 https://www.upstage.ai/pricing 참조
---
## Python 구현 예시
```python
import httpx, base64, json
from pathlib import Path
async def upstage_parse(api_key: str, file_path: str) -> dict:
with open(file_path, "rb") as f:
file_bytes = f.read()
filename = Path(file_path).name
ext = Path(file_path).suffix.lower()
mime = {"pdf": "application/pdf", "png": "image/png", "jpg": "image/jpeg"}.get(ext[1:], "application/octet-stream")
async with httpx.AsyncClient(timeout=120) as client:
response = await client.post(
"https://api.upstage.ai/v1/document-ai/document-digitization",
headers={"Authorization": f"Bearer {api_key}"},
files={"document": (filename, file_bytes, mime)},
data={
"model": "document-parse-ocr",
"ocr": "auto",
"output_formats": '["text", "html", "markdown"]'
}
)
return response.json()
async def upstage_extract(api_key: str, file_path: str, schema: dict) -> dict:
with open(file_path, "rb") as f:
file_bytes = f.read()
filename = Path(file_path).name
async with httpx.AsyncClient(timeout=120) as client:
response = await client.post(
"https://api.upstage.ai/v1/document-ai/information-extraction",
headers={"Authorization": f"Bearer {api_key}"},
files={"document": (filename, file_bytes, "application/pdf")},
data={"schema": json.dumps(schema, ensure_ascii=False)}
)
return response.json()
```

276
.claude/skills/workspace-analyzer/SKILL.md
View File

@ -1,276 +0,0 @@
---
name: workspace-analyzer
description: >
워크스페이스에 소스코드를 넣으면 자동으로 분석·하네스 적용·개발환경 가이드를 제공하는 스킬.
다음 상황에서 반드시 사용:
(1) "workspace 폴더에 소스 넣었어", "소스 분석해줘", "하네스 적용해줘" 요청;
(2) workspace/ 하위 폴더에 새 프로젝트가 있을 때;
(3) "개발환경 가이드", "이 소스 어떻게 돌려?", "의존성 뭐야?" 질문;
(4) "프로젝트 분석", "코드베이스 파악", "기술스택 알려줘" 요청;
(5) 처음 보는 레포지토리를 분석해야 할 때.
workspace/ 폴더에 소스가 없을 때도 분석 요청이 오면 이 스킬을 먼저 실행하라.
---
# Workspace 소스 자동분석 + 하네스 적용 + 개발환경 가이드
소스코드를 `workspace/<프로젝트명>/` 에 넣으면 자동으로 3단계를 수행한다.
---
## Phase 0: 워크스페이스 탐색
```
1. Glob("workspace/**") 으로 프로젝트 폴더 목록 확인
2. 분석 대상 폴더 결정:
- 사용자가 폴더명을 명시한 경우 → 해당 폴더
- 명시 없으면 가장 최근 수정된 폴더 (수정 시간 기준)
- 폴더가 없으면 → "workspace/<프로젝트명>/ 폴더를 만들고 소스를 넣어주세요." 안내
```
---
## Phase 1: 기술스택 자동 탐지
아래 파일 존재 여부로 스택을 판별한다.
| 파일 | 스택 |
|------|------|
| `pom.xml` / `build.gradle` | Java (Maven/Gradle) |
| `package.json` | Node.js / React / Vue / Next.js |
| `requirements.txt` / `pyproject.toml` / `setup.py` | Python |
| `composer.json` | PHP |
| `Gemfile` | Ruby on Rails |
| `go.mod` | Go |
| `Cargo.toml` | Rust |
| `*.csproj` / `*.sln` | .NET / C# |
| `Dockerfile` / `docker-compose.yml` | 컨테이너 |
| `.env.example` / `application.yml` | 설정 파일 |
**탐지 순서:**
1. Glob으로 루트 파일 목록 확인
2. 없으면 1~2 depth 하위까지 탐색
3. 여러 스택 감지 시 → 멀티스택으로 처리
---
## Phase 2: 심층 분석 (스택별)
### Java 프로젝트
```
필독 파일: pom.xml 또는 build.gradle (의존성), src/main/resources/application*.yml (설정)
분석 항목:
- Spring Boot 버전, JDK 버전
- 주요 의존성 (JPA, Security, MyBatis, Redis 등)
- DB 설정 (datasource)
- 포트 (server.port, 기본 8080)
- 프로파일 구조 (dev/stg/prd)
- 테스트 프레임워크 (JUnit 5, Mockito)
```
### Python 프로젝트
```
필독 파일: requirements.txt 또는 pyproject.toml, .env.example
분석 항목:
- FastAPI/Django/Flask/Flask 버전
- Python 버전 (.python-version, runtime.txt)
- DB ORM (SQLAlchemy, Django ORM, Tortoise)
- 주요 패키지 (celery, redis, boto3 등)
- 실행 진입점 (main.py, app.py, manage.py, wsgi.py)
```
### Node.js 프로젝트
```
필독 파일: package.json, .env.example, next.config.js
분석 항목:
- 프레임워크 (Next.js, Express, Nest.js, React 순수)
- Node 버전 (.nvmrc, engines 필드)
- 주요 의존성 (ORM, auth, 상태관리 등)
- scripts 명령어 (start, build, dev, test)
- 빌드 도구 (webpack, vite, turbopack)
```
### PHP 프로젝트
```
필독 파일: composer.json, .env.example
분석 항목:
- 프레임워크 (Laravel, Symfony, CodeIgniter, 순수 PHP)
- PHP 버전 (require 필드)
- DB (Eloquent, Doctrine, mysqli)
- 아티즌 명령어 (Laravel일 때)
```
---
## Phase 3: 분석 결과 리포트
다음 형식으로 사용자에게 보고한다:
```markdown
## 소스 분석 결과: {프로젝트명}
### 기술 스택
- 언어: {언어 및 버전}
- 프레임워크: {프레임워크 및 버전}
- DB: {DB 종류}
- 기타: {주요 라이브러리}
### 프로젝트 구조
{핵심 폴더/파일 트리 — 5~10개}
### 진입점
- 실행 명령: `{실행 명령어}`
- 기본 포트: {포트번호}
- 설정 파일: `{설정 파일 경로}`
```
---
## Phase 4: 개발환경 가이드 생성
스택에 맞는 설치 명령어와 실행 방법을 단계별로 제공한다.
### Java (Spring Boot)
```bash
# 1. JDK 설치 확인
java -version # JDK 17+ 필요 (pom.xml java.version 확인)
# 2. 빌드 (Maven)
./mvnw clean package -DskipTests
# 3. DB 설정 (application-local.yml 생성)
# spring.datasource.url, username, password 설정
# 4. 실행
./mvnw spring-boot:run -Dspring-boot.run.profiles=local
# 또는
java -jar target/{artifact}.jar --spring.profiles.active=local
```
### Python (FastAPI/Django)
```bash
# 1. 가상환경
python3.11 -m venv venv && source venv/bin/activate # Linux/Mac
python -m venv venv && venv\Scripts\activate # Windows
# 2. 의존성 설치
pip install -r requirements.txt
# 3. 환경변수 설정
cp .env.example .env # .env 편집 후 DB URL, SECRET_KEY 설정
# 4. DB 초기화 (있으면)
alembic upgrade head # 또는 python manage.py migrate
# 5. 실행
uvicorn main:app --reload --port 8000 # FastAPI
python manage.py runserver 0:8000 # Django
```
### Node.js
```bash
# 1. Node.js 버전 확인 (.nvmrc 있으면 nvm use)
node --version
# 2. 의존성 설치
npm install # 또는 yarn install / pnpm install
# 3. 환경변수
cp .env.example .env
# 4. DB 마이그레이션 (있으면)
npx prisma migrate dev # Prisma
npm run typeorm:migration:run # TypeORM
# 5. 실행
npm run dev # 개발
npm run build && npm start # 빌드 후 실행
```
---
## Phase 5: 하네스 적용
프로젝트 유형에 따라 `.claude/` 하네스를 자동 생성한다.
### 하네스 생성 원칙
- `workspace/{project}/.claude/agents/` 에 에이전트 생성
- `workspace/{project}/.claude/skills/` 에 스킬 생성
- 프레임워크 특성에 맞는 전문 에이전트 구성
### Java Spring Boot 하네스 구성
| 에이전트 | 역할 |
|---------|------|
| `java-dev` | 기능 개발, 테스트 작성 |
| `db-migrator` | 엔티티/마이그레이션 관리 |
| `api-reviewer` | REST API 설계 검토 |
스킬: `run-tests`, `build-check`, `api-spec`
### Python FastAPI 하네스 구성
| 에이전트 | 역할 |
|---------|------|
| `py-dev` | 기능 개발, 의존성 관리 |
| `db-migrator` | Alembic 마이그레이션 |
| `test-runner` | pytest 실행 및 커버리지 |
스킬: `run-tests`, `lint-check`, `type-check`
### Node.js 하네스 구성
| 에이전트 | 역할 |
|---------|------|
| `frontend-dev` | 컴포넌트/페이지 개발 |
| `backend-dev` | API 라우터 개발 |
| `test-runner` | Jest/Vitest 실행 |
스킬: `lint`, `type-check`, `build-check`
### 범용 에이전트 (모든 프로젝트 공통)
| 에이전트 | 역할 |
|---------|------|
| `code-reviewer` | PR 리뷰, 보안 검토 |
| `doc-writer` | README, API 문서 생성 |
---
## Phase 6: CLAUDE.md 자동 생성
`workspace/{project}/CLAUDE.md` 를 자동 생성한다. 포함 내용:
- 프로젝트 개요 및 기술스택
- 디렉토리 구조 (핵심 경로만)
- 실행 명령어 (개발/빌드/테스트)
- 환경변수 목록
- 보안 주의사항 (있으면)
- 하네스 트리거 규칙
---
## 실행 흐름 요약
```
사용자가 소스를 workspace/<proj>/에 넣음
↓
Phase 0: workspace/ 탐색
↓
Phase 1: 기술스택 파일 탐지 (Glob)
↓
Phase 2: 핵심 파일 읽기 (Read)
↓
Phase 3: 분석 리포트 출력
↓
Phase 4: 개발환경 가이드 출력
↓
Phase 5: .claude/ 하네스 생성 (에이전트 + 스킬)
↓
Phase 6: CLAUDE.md 생성
↓
사용자 확인 → 추가 분석 or 개발 시작
```
---
## 주의사항
- **보안**: 소스 내 `.env`, `secrets.yml`, 비밀번호 패턴 발견 시 즉시 경고
- **외부 API 금지**: 분석 중 외부 서비스 호출 금지 (Ollama만 허용)
- **파일 무결성**: workspace/ 소스를 수정하지 않는다 — 분석과 가이드만
- **대용량 파일**: 10,000줄 이상 파일은 헤더/핵심 섹션만 읽는다

166
.claude/skills/workspace-reorganize-orchestrator/SKILL.md
View File

@ -1,166 +0,0 @@
---
name: workspace-reorganize-orchestrator
description: "C:\\GUARDiA 모노레포의 소스를 workspace/ 하위로 통합 재구성하는 오케스트레이터. itsm/→workspace/guardia-itsm/, manager/→workspace/guardia-manager/, app/→workspace/guardia-messenger/, manual/→workspace/guardia-docs/ 이동. git mv로 히스토리 보존, 모든 경로 참조 일괄 업데이트. 다음 상황에서 반드시 사용: (1) 'workspace로 이동', '소스 workspace 통합', '프로젝트별 workspace 정리'; (2) 'git mv 히스토리 보존 이동'; (3) 이동 후 경로 참조 업데이트; (4) 다시 실행, 업데이트, 수정, 보완."
---
# workspace 통합 재구성 오케스트레이터
**실행 모드:** 파이프라인 (순차 서브 에이전트)
`workspace-mover` → `path-updater` → `integrity-checker`
---
## 목표 구조
```
현재 이동 후
C:\GUARDiA\ C:\GUARDiA\
├── workspace/ └── workspace/
│ └── zioinfo-web/ ├── zioinfo-web/ (유지)
├── itsm/ → ├── guardia-itsm/ (itsm/)
├── manager/ → ├── guardia-manager/ (manager/)
├── app/ → ├── guardia-messenger/ (app/)
└── manual/ → └── guardia-docs/ (manual/)
```
---
## Phase 0: 사전 확인
```bash
cd C:\GUARDiA
# 미커밋 변경사항 확인 (없어야 함)
git status --short | grep -v "^??" | head -10
# 이동 대상 디렉토리 존재 확인
for d in itsm manager app manual; do
[ -d "$d" ] && echo "OK: $d exists" || echo "SKIP: $d not found"
done
# workspace/ 디렉토리 존재 확인
[ -d "workspace" ] && echo "OK: workspace exists"
```
⚠️ **사전 조건:**
- 미커밋 변경사항 없을 것 (있으면 먼저 커밋 또는 stash)
- `workspace/` 디렉토리 존재할 것
---
## Phase 1: git mv 이동 (workspace-mover)
```bash
cd C:\GUARDiA
# 4개 디렉토리 이동 (한 번에 처리)
git mv itsm workspace/guardia-itsm
git mv manager workspace/guardia-manager
git mv app workspace/guardia-messenger
git mv manual workspace/guardia-docs
# 상태 확인
git status --short | head -20
# 하나의 커밋으로 처리
git commit -m "refactor(structure): consolidate all projects under workspace/
- itsm/ → workspace/guardia-itsm/
- manager/ → workspace/guardia-manager/
- app/ → workspace/guardia-messenger/
- manual/ → workspace/guardia-docs/
workspace/zioinfo-web/ unchanged.
git mv preserves full commit history."
```
---
## Phase 2: 경로 참조 업데이트 (path-updater)
### 2-1. CLAUDE.md (루트) 업데이트
경로 매핑:
```
itsm/ → workspace/guardia-itsm/
manager/ → workspace/guardia-manager/
app/ → workspace/guardia-messenger/
manual/ → workspace/guardia-docs/
--prefix=itsm → --prefix=workspace/guardia-itsm
--prefix=manager → --prefix=workspace/guardia-manager
--prefix=app → --prefix=workspace/guardia-messenger
--prefix=manual → --prefix=workspace/guardia-docs
```
### 2-2. .claude/agents/repo-splitter.md 업데이트
```markdown
# 이전
git subtree split --prefix=itsm -b split/guardia-itsm
git subtree split --prefix=manager -b split/guardia-manager
git subtree split --prefix=app -b split/guardia-messenger
git subtree split --prefix=manual -b split/guardia-docs
# 이후
git subtree split --prefix=workspace/guardia-itsm -b split/guardia-itsm
git subtree split --prefix=workspace/guardia-manager -b split/guardia-manager
git subtree split --prefix=workspace/guardia-messenger -b split/guardia-messenger
git subtree split --prefix=workspace/guardia-docs -b split/guardia-docs
```
### 2-3. .claude/skills/repo-split-orchestrator/SKILL.md 업데이트
subtree split prefix 경로 모두 업데이트.
### 2-4. 수동 변경 후 커밋
```bash
git add .claude/ CLAUDE.md
git commit -m "refactor(paths): update all path references after workspace reorganization"
```
---
## Phase 3: 무결성 검증 (integrity-checker)
```bash
# 히스토리 보존 확인
git log --oneline --follow workspace/guardia-itsm/main.py | head -3
# 구조 확인
ls workspace/
# 예상: guardia-docs guardia-itsm guardia-manager guardia-messenger zioinfo-web
# 원본 경로 없음 확인
test ! -d itsm && test ! -d manager && test ! -d app && test ! -d manual
echo "원본 디렉토리 제거 완료"
# 경로 참조 잔재 확인
grep -r "\"itsm" CLAUDE.md 2>/dev/null | grep -v "guardia-itsm" && echo "WARN" || echo "OK"
grep -r "prefix=app" .claude/ 2>/dev/null | grep -v "guardia-messenger" && echo "WARN" || echo "OK"
```
---
## 완료 후 변경 필요 항목 (manual 작업)
서버의 `deploy_server.py`는 서버 소스 경로(독립 repo)를 참조하므로 **변경 불필요**.
독립 repos(`C:\GUARDiA\repos\`)는 이미 분리됐으므로 **변경 불필요**.
---
## 에러 핸들링
| 오류 | 원인 | 해결 |
|------|------|------|
| `git mv` 실패 | 미커밋 변경사항 | `git stash` 후 재실행 |
| 타겟 경로 존재 | 이미 이동됨 | `git status` 확인 |
| 히스토리 단절 | 일반 mv 사용 | `git log --follow`로 확인 |
| 경로 참조 누락 | grep으로 탐지 | 수동 수정 |
---
## 테스트 시나리오
**정상:** git mv 4개 → 히스토리 확인 → 경로 업데이트 → grep 잔재 없음
**에러:** itsm/ 없음 → "SKIP: itsm not found" 경고 후 나머지 진행

247
.claude/skills/zioinfo-mail-orchestrator/SKILL.md
View File

@ -1,247 +0,0 @@
---
name: zioinfo-mail-orchestrator
description: >
zioinfo-mail 웹메일 시스템 구축 오케스트레이터.
지오정보기술 SMTP 서버(Postfix + Dovecot)를 활용한 React+FastAPI 웹메일 클라이언트를
workspace/zioinfo-mail/ 에 구축하고 서버(mail.zioinfo.co.kr:8025)에 배포한다.
FastAPI IMAP/SMTP 프록시 백엔드, React 3-패널 메일 UI 프론트엔드, nginx+systemd 인프라를
에이전트 팀으로 병렬 구현한다.
다음 상황에서 반드시 사용:
(1) 'webmail', '웹메일', 'zioinfo-mail', '메일 시스템 구축';
(2) '메일 클라이언트', '이메일 UI', 'IMAP 연동', 'SMTP 연동';
(3) mail.zioinfo.co.kr 관련 작업;
(4) 다시 실행, 업데이트, 수정, 보완.
---
# zioinfo-mail 웹메일 시스템 오케스트레이터
**실행 모드:** 하이브리드
- Phase 1 (인프라 검증): 서브 에이전트 (mail-infra-setup)
- Phase 2 (Backend + Frontend 구현): **병렬 서브 에이전트**
- Phase 3 (통합 배포): 에이전트 팀 (3명 협업)
---
## 시스템 개요
```
사용자 브라우저
↓ HTTPS:8025
nginx (/var/www/mail) → React SPA
↓ /api/
FastAPI (127.0.0.1:8026)
↓ IMAP:993 (SSL) ↓ SMTP:587 (STARTTLS)
Dovecot Postfix
(읽기) (발송)
```
**기존 인프라:**
| 항목 | 값 |
|------|-----|
| Postfix | active, `mail.zioinfo.co.kr` |
| Dovecot | active, IMAP/POP3, maildir:~/Maildir |
| TLS cert | `/etc/ssl/guardia/server.crt` |
| 계정 | ythong / info / admin @zioinfo.co.kr |
| 웹메일 URL | `https://mail.zioinfo.co.kr:8025` |
---
## Phase 0: 컨텍스트 확인
```
workspace/zioinfo-mail/ 존재 여부:
- 없음 → 초기 구현 (Phase 1부터 전체)
- 있음 + backend/만 요청 → mail-backend-dev만 재실행
- 있음 + frontend/만 요청 → mail-frontend-dev만 재실행
- 있음 + 배포 요청 → Phase 3만 실행
```
---
## Phase 1: 인프라 사전 검증 (서브 에이전트)
**mail-infra-setup** 에이전트 실행 (읽기 전용 검증):
```python
# 검증 항목
1. IMAP localhost:993 접속 테스트
2. SMTP localhost:587 접속 테스트
3. 포트 8025/8026 사용 가능 여부
4. /opt/mail/, /var/www/mail/ 생성 가능 여부
5. Gitea zio/zioinfo-mail 저장소 존재 여부
```
결과를 `_workspace/infra-check.json`에 저장.
IMAP/SMTP 접속 실패 시 → Postfix/Dovecot 설정 점검 후 재시도.
---
## Phase 2: Backend + Frontend 병렬 구현 (서브 에이전트)
**mail-backend-dev** + **mail-frontend-dev** 동시 실행:
### mail-backend-dev 작업 목록
```
workspace/zioinfo-mail/backend/
├── main.py ← FastAPI 앱 (포트 8026)
├── auth.py ← IMAP 로그인 → JWT 발급
├── imap_client.py ← aioimaplib 연결 풀
├── smtp_client.py ← aiosmtplib 발송
├── mail_parser.py ← 메일 파싱 (한글, 첨부파일)
├── models.py ← Pydantic 스키마
└── requirements.txt
```
**핵심 구현 포인트:**
- JWT 페이로드에 IMAP 자격증명 AES 암호화 포함
- IMAP 연결 풀: 사용자당 1개 재사용
- 한글 제목/본문 인코딩: `chardet` + `email.header.decode_header`
- 첨부파일: `/tmp/mail_attach_{uid}/` 임시 저장 후 스트리밍
### mail-frontend-dev 작업 목록
```
workspace/zioinfo-mail/frontend/
├── package.json ← react, typescript, vite, axios, zustand, dompurify
├── vite.config.ts ← outDir: '../dist', proxy: /api → :8026
├── src/
│ ├── App.tsx
│ ├── pages/Login.tsx ← 로그인
│ ├── pages/Mail.tsx ← 3-패널 메인
│ ├── components/
│ │ ├── FolderTree.tsx ← 좌측 폴더 트리
│ │ ├── MailList.tsx ← 중앙 목록
│ │ ├── MailView.tsx ← 우측 본문
│ │ └── Compose.tsx ← 작성 모달
│ ├── api/mailApi.ts ← axios 클라이언트
│ └── store/mailStore.ts ← zustand
```
**Backend API 스펙** (`_workspace/api-spec.md` 참조):
- Backend 완료 후 API 스펙 파일 생성 → Frontend에서 읽어 구현
---
## Phase 3: 통합 배포 (에이전트 팀)
3명 팀 구성: mail-backend-dev + mail-frontend-dev + mail-infra-setup
### 3-1. Frontend 빌드
```bash
cd workspace/zioinfo-mail/frontend && npm run build
# dist/ → workspace/zioinfo-mail/dist/
```
### 3-2. 서버 업로드 (mail-infra-setup 담당)
```bash
# Backend: paramiko sftp → /opt/mail/backend/
# Frontend dist: bundle → /var/www/mail/
# Python venv: pip install requirements.txt
```
### 3-3. systemd + nginx 설정
```bash
# /etc/systemd/system/zioinfo-mail.service 작성
# /etc/nginx/sites-available/zioinfo-mail 작성
# systemctl enable + start zioinfo-mail
# nginx -t && systemctl reload nginx
# ufw allow 8025/tcp
```
### 3-4. Gitea repo 생성 + push
```bash
# Gitea API로 zio/zioinfo-mail repo 생성
# repos/zioinfo-mail/ 로컬 git init
# bundle → server → push
```
### 3-5. deploy_server.py에 zioinfo-mail 추가
```python
# /opt/zioinfo/deploy_server.py에 zioinfo-mail 배포 함수 추가
elif repo == "zioinfo-mail":
steps = [
("git pull", [...]),
("npm build", [...]),
("copy dist", ["bash", "-c", "cp -r {SRC}/dist/. /var/www/mail/"]),
("pip install", [...]),
("restart", ["systemctl", "restart", "zioinfo-mail"]),
("health check", [...]),
]
```
---
## Phase 4: 검증
```bash
# 1. 서비스 상태
systemctl is-active zioinfo-mail
curl -f http://localhost:8026/health
# 2. IMAP 로그인 테스트
curl -X POST http://localhost:8026/auth/login \
-d '{"username":"ythong@zioinfo.co.kr","password":"1q2w3e!Q"}'
# 3. 메일 목록 조회
curl http://localhost:8026/mail/messages \
-H "Authorization: Bearer {token}"
# 4. nginx 응답
curl -f http://localhost:8025/
```
---
## 데이터 흐름
```
_workspace/
├── infra-check.json ← Phase 1 결과
├── api-spec.md ← Backend → Frontend 전달
└── deploy-result.json ← Phase 3 결과
```
---
## 에러 핸들링
| 에러 | 원인 | 처리 |
|------|------|------|
| IMAP 연결 실패 | Dovecot SSL 설정 | `/etc/ssl/guardia/server.crt` 확인 |
| SMTP 인증 실패 | SASL 설정 | `postconf smtpd_sasl_*` 확인 |
| npm build 실패 | node_modules 없음 | `npm ci` 재시도 |
| 포트 충돌 | 8026 이미 사용 | 8027로 변경 |
| HTML 메일 XSS | DOMPurify 미적용 | iframe sandbox 사용 |
---
## 테스트 시나리오
**정상 흐름:**
1. `https://mail.zioinfo.co.kr:8025` 접속
2. `ythong@zioinfo.co.kr` / `1q2w3e!Q` 로그인
3. 받은메함 목록 표시
4. 메일 클릭 → 본문 조회
5. 작성 → To: `info@zioinfo.co.kr` → 발송
6. 발신 계정 받은메함에서 수신 확인
**에러 흐름:**
- 잘못된 비밀번호 → 401 응답 + "인증 실패" 메시지
---
## should-trigger
- "웹메일 만들어줘"
- "zioinfo-mail 구축"
- "메일 클라이언트 개발"
- "mail.zioinfo.co.kr 배포"
- "IMAP 연동 웹메일"
- "다시 실행", "수정", "보완"
## should-NOT-trigger
- "GUARDiA에서 메일 알림 보내줘" → guardia-orchestrator (ITSM 알림)
- "메일 서버 설정해줘" → Postfix/Dovecot 직접 설정 (인프라 작업)
- "홈페이지 문의 메일 연동" → homepage-cms-orchestrator

144
.claude/skills/zioinfo-mail-orchestrator/references/backend-template.py
View File

@ -1,144 +0,0 @@
"""
zioinfo-mail FastAPI 백엔드 템플릿
mail-backend-dev 에이전트가 이 파일을 기반으로 확장 구현한다.
"""
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from typing import Optional
import asyncio, aioimaplib, aiosmtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
import email.header, chardet, ssl
from jose import jwt
from cryptography.fernet import Fernet
import os, json, base64, hashlib
from datetime import datetime, timedelta
app = FastAPI(title="zioinfo-mail API", version="1.0.0")
app.add_middleware(CORSMiddleware,
allow_origins=["https://mail.zioinfo.co.kr", "http://localhost:5173"],
allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
# ── 설정 ────────────────────────────────────────────────────
IMAP_HOST = "localhost"; IMAP_PORT = 993
SMTP_HOST = "localhost"; SMTP_PORT = 587
JWT_SECRET = os.getenv("MAIL_JWT_SECRET", "change-me-in-production")
JWT_EXPIRE_HOURS = 8
# IMAP 자격증명 암호화 키 (32바이트 → Fernet)
FERNET_KEY = os.getenv("MAIL_FERNET_KEY",
base64.urlsafe_b64encode(hashlib.sha256(JWT_SECRET.encode()).digest()))
fernet = Fernet(FERNET_KEY)
# ── 모델 ────────────────────────────────────────────────────
class LoginRequest(BaseModel):
username: str # user@zioinfo.co.kr
password: str
class SendRequest(BaseModel):
to: str; cc: Optional[str] = None; bcc: Optional[str] = None
subject: str; body: str; html: bool = False
reply_to_uid: Optional[str] = None
# ── 인증 ────────────────────────────────────────────────────
async def verify_imap(username: str, password: str) -> bool:
"""IMAP 로그인으로 자격증명 검증"""
try:
ssl_ctx = ssl.create_default_context()
ssl_ctx.check_hostname = False
ssl_ctx.verify_mode = ssl.CERT_NONE
imap = aioimaplib.IMAP4_SSL(IMAP_HOST, IMAP_PORT, ssl_context=ssl_ctx)
await imap.wait_hello_from_server()
res, _ = await imap.login(username, password)
await imap.logout()
return res == "OK"
except Exception:
return False
def create_token(username: str, password: str) -> str:
enc_pw = fernet.encrypt(password.encode()).decode()
payload = {
"sub": username,
"pw": enc_pw,
"exp": datetime.utcnow() + timedelta(hours=JWT_EXPIRE_HOURS)
}
return jwt.encode(payload, JWT_SECRET, algorithm="HS256")
def get_credentials(token: str = Depends(lambda: None)) -> tuple[str, str]:
from fastapi import Header
# FastAPI security dependency - 실제 구현에서 Bearer 헤더에서 추출
try:
payload = jwt.decode(token, JWT_SECRET, algorithms=["HS256"])
username = payload["sub"]
password = fernet.decrypt(payload["pw"].encode()).decode()
return username, password
except Exception:
raise HTTPException(status.HTTP_401_UNAUTHORIZED)
# ── 엔드포인트 ───────────────────────────────────────────────
@app.get("/health")
async def health():
return {"status": "ok", "service": "zioinfo-mail"}
@app.post("/auth/login")
async def login(req: LoginRequest):
if not await verify_imap(req.username, req.password):
raise HTTPException(status.HTTP_401_UNAUTHORIZED, "인증 실패")
token = create_token(req.username, req.password)
return {"access_token": token, "token_type": "bearer", "username": req.username}
# ── 메일 파싱 유틸 ───────────────────────────────────────────
def decode_header_str(raw: str) -> str:
"""RFC2047 인코딩된 헤더 디코딩 (한글 포함)"""
parts = email.header.decode_header(raw or "")
result = []
for part, charset in parts:
if isinstance(part, bytes):
charset = charset or chardet.detect(part).get('encoding', 'utf-8') or 'utf-8'
result.append(part.decode(charset, errors='replace'))
else:
result.append(part)
return "".join(result)
def parse_message(msg) -> dict:
"""email.message.Message → dict"""
body_text = body_html = ""
attachments = []
if msg.is_multipart():
for part in msg.walk():
ct = part.get_content_type()
cd = str(part.get('Content-Disposition', ''))
if ct == 'text/plain' and 'attachment' not in cd:
body_text = _decode_payload(part)
elif ct == 'text/html' and 'attachment' not in cd:
body_html = _decode_payload(part)
elif 'attachment' in cd or part.get_filename():
attachments.append({
"filename": decode_header_str(part.get_filename() or "unnamed"),
"content_type": ct,
"size": len(part.get_payload(decode=True) or b""),
})
else:
ct = msg.get_content_type()
if ct == 'text/html':
body_html = _decode_payload(msg)
else:
body_text = _decode_payload(msg)
return {
"subject": decode_header_str(msg.get("Subject", "")),
"from": decode_header_str(msg.get("From", "")),
"to": decode_header_str(msg.get("To", "")),
"cc": decode_header_str(msg.get("Cc", "")),
"date": msg.get("Date", ""),
"body_text": body_text,
"body_html": body_html,
"attachments": attachments,
}
def _decode_payload(part) -> str:
raw = part.get_payload(decode=True) or b""
charset = part.get_content_charset() or chardet.detect(raw).get('encoding', 'utf-8') or 'utf-8'
return raw.decode(charset, errors='replace')

63
.dockerignore
View File

@ -1,63 +0,0 @@
# Git
.git/
.gitignore
# Python
__pycache__/
*.pyc
*.pyo
*.pyd
.pytest_cache/
*.egg-info/
dist/
build/
.eggs/
venv/
.venv/
env/
# 개발 도구
.vscode/
.idea/
*.swp
*.swo
# 테스트
tests/
test_*.py
*.test.py
# 문서/설정
docs/
manual/
*.md
*.txt
!requirements.txt
# 데이터
*.db
*.sqlite
*.sqlite3
guardia_itsm.db*
# 업로드
uploads/
*.log
# 환경 파일 (보안)
.env
.env.*
*.env
secrets/
# Docker 패키지
docker-package/
# 설치 스크립트
setup/
# workspace
workspace/
# Claude
.claude/

153
.gitea/workflows/ci.yml
View File

@ -1,153 +0,0 @@
# GUARDiA ITSM — Gitea Actions CI/CD
# 트리거: PR (feature → develop), Push (develop, main)
# 목적: Python 문법 검사 + 임포트 테스트 + 설치 스크립트 검증
name: GUARDiA CI
on:
push:
branches:
- main
- develop
- 'feature/**'
pull_request:
branches:
- main
- develop
env:
PYTHON_VERSION: "3.11"
jobs:
# ── 1. Python 코드 품질 검사 ─────────────────────────────────
lint-and-test:
name: Python Lint & Import Test
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Setup Python ${{ env.PYTHON_VERSION }}
uses: actions/setup-python@v4
with:
python-version: ${{ env.PYTHON_VERSION }}
- name: Install dependencies
run: |
cd itsm
pip install --upgrade pip -q
pip install -r requirements.txt -q
pip install flake8 -q
- name: Flake8 (문법/스타일 검사)
run: |
cd itsm
# 오류만 체크 (경고는 무시) — E9xx, F4xx, F8xx만
flake8 . --count --select=E9,F401,F811,F821,F841 \
--exclude=__pycache__,.git,static \
--max-line-length=200 \
--statistics
continue-on-error: false
- name: 모듈 임포트 테스트
run: |
cd itsm
python -c "
import sys, os
sys.path.insert(0, '.')
os.chdir('.')
modules = [
'models', 'database',
'core.auth', 'core.license', 'core.oauth',
'core.auto_rca', 'core.deploy_impact',
'core.ticket_classifier', 'core.jira_sync',
'core.push_notify', 'core.scheduler',
'routers.tasks', 'routers.approvals',
'routers.messenger', 'routers.vuln_scan',
'routers.gateway', 'routers.license',
'routers.push', 'routers.incidents',
'routers.problem', 'routers.vibe',
]
errors = []
for m in modules:
try:
__import__(m)
print(f'[OK] {m}')
except Exception as e:
print(f'[ERR] {m}: {e}')
errors.append(m)
if errors:
print(f'\\nFailed: {errors}')
sys.exit(1)
print('\\n모든 모듈 임포트 성공')
"
- name: FastAPI 앱 로드 테스트
run: |
cd itsm
python -c "
import sys, os
sys.path.insert(0, '.')
os.chdir('.')
from main import app
routes = [r.path for r in app.routes if hasattr(r, 'path')]
assert len(routes) > 100, f'라우트 수 부족: {len(routes)}'
print(f'FastAPI 앱 로드 성공 — {len(routes)}개 라우트')
"
# ── 2. 설치 스크립트 검증 ─────────────────────────────────────
validate-scripts:
name: Validate Install Scripts
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Bash 스크립트 구문 검사
run: |
echo "=== Bash 스크립트 구문 검사 ==="
FAIL=0
for f in setup/*.sh setup/lib/*.sh; do
bash -n "$f" && echo "[OK] $f" || { echo "[ERR] $f"; FAIL=1; }
done
for f in itsm/cicd/scripts/**/*.sh; do
[ -f "$f" ] && { bash -n "$f" && echo "[OK] $f" || { echo "[ERR] $f"; FAIL=1; }; }
done
[ $FAIL -eq 0 ] || exit 1
- name: Docker Compose YAML 검증
run: |
python3 -c "
import yaml
for f in ['docker-compose.yml', 'docker-compose.prod.yml']:
with open(f, encoding='utf-8') as fp:
yaml.safe_load(fp)
print(f'[OK] {f}')
"
- name: db_init.py 검증
run: |
python3 -c "
import ast
with open('itsm/tools/db_init.py', encoding='utf-8') as f:
ast.parse(f.read())
print('[OK] itsm/tools/db_init.py')
"
# ── 3. PR 검증 요약 ──────────────────────────────────────────
pr-summary:
name: PR Validation Summary
runs-on: ubuntu-latest
needs: [lint-and-test, validate-scripts]
if: github.event_name == 'pull_request'
steps:
- name: PR 통과
run: |
echo "✅ PR 검증 통과"
echo " - Python 코드 품질: 통과"
echo " - 모듈 임포트: 통과"
echo " - 설치 스크립트: 통과"
echo ""
echo "이제 리뷰어 승인을 받아 병합할 수 있습니다."

71
.gitignore vendored
View File

@ -1,66 +1,7 @@
# Python
__pycache__/
*.py[cod]
*.pyo
*.pyd
.Python
*.egg
*.egg-info/
dist/
build/
.eggs/
# Virtual environments
venv/
.venv/
env/
ENV/
# Environment variables
.env
.env.*
!.env.example
# Database
*.db
*.sqlite3
# IDE
.vscode/
.idea/
*.swp
*.swo
# OS
.DS_Store
Thumbs.db
desktop.ini
# Logs
*.log
logs/
# Node.js
node_modules/
npm-debug.log*
# 분리된 독립 repo 디렉토리 (모노레포에서 제외)
repos/
# Claude Code local settings
.claude/settings.local.json
# Secrets
secrets/
*.pem
*.key
*.crt
deploy_*.py
check_*.py
capture_*.py
install_*.py
test_*.py
redeploy_*.py
debug_*.py
app_screens.html
dist/
__pycache__/
*.pyc
.env
*.db
.tsbuildinfo

446
CLAUDE.md
View File

@ -1,446 +0,0 @@
# GUARDiA — AI 기반 레거시 인프라 자율 운영 플랫폼
> **Claude Code용 프로젝트 마스터 컨텍스트 파일**
> 이 파일을 읽고 프로젝트의 전체 구조와 규칙을 파악한 뒤 작업을 시작하라.
---
## 프로젝트 비전
1,000개 이상의 다중 관공서(Multi-tenant) 레거시 인프라를 타겟으로 하는
**AI 기반 통합 ChatOps 오케스트레이션 플랫폼**.
- 메신저 한 줄 명령 → sLLM 파싱 → 에이전트리스(SSH/SFTP) 배포·운영 자동화
- 에이전트 설치 **불필요** — 표준 SSH/FTP 프로토콜만 활용
- 개발(Dev), SM 운영, PM 관리 세 역할의 워크플로우를 단일 메신저로 통합
---
## 디렉터리 구조
```
C:\GUARDiA\
├── CLAUDE.md # ← 지금 이 파일 (Claude Code 진입점)
├── docs/ # 설계 문서 (아키텍처 명세 등)
├── workspace/ # ← 모든 프로젝트 소스 (2026-05-31 통합)
│ ├── zioinfo-web/ # 지오정보기술 홈페이지 (Spring Boot + React)
│ ├── guardia-itsm/ # GUARDiA ITSM 웹 애플리케이션 (FastAPI)
│ ├── guardia-manager/ # GUARDiA 관리자 포털 (FastAPI + React)
│ ├── guardia-messenger/ # GUARDiA Messenger 앱 (React Native + Expo)
│ └── guardia-docs/ # 매뉴얼 및 운영 가이드 문서
├── repos/ # 독립 Gitea 저장소 (git push 용)
│ ├── zioinfo-web/ → Gitea zio/zioinfo-web
│ ├── guardia-itsm/ → Gitea zio/guardia-itsm
│ ├── guardia-manager/ → Gitea zio/guardia-manager
│ ├── guardia-messenger/ → Gitea zio/guardia-messenger
│ └── guardia-docs/ → Gitea zio/guardia-docs
└── .claude/ # 하네스 에이전트 + 스킬
# 이전 경로 (2026-05-31 이전)
# itsm/ → workspace/guardia-itsm/
# manager/ → workspace/guardia-manager/
# app/ → workspace/guardia-messenger/
# manual/ → workspace/guardia-docs/
```
---
## workspace/guardia-itsm 구조 (GUARDiA ITSM)
```
workspace/guardia-itsm/
│ ├── main.py # FastAPI 앱 진입점 (포트 8001)
│ ├── models.py # SQLAlchemy ORM 모델 + Pydantic 스키마
│ ├── main.py # FastAPI 앱 진입점 (포트 8001)
│ ├── models.py # SQLAlchemy ORM 모델 + Pydantic 스키마
│ ├── database.py # DB 연결 및 세션
│ ├── core/
│ │ ├── auth.py # JWT 인증, RBAC
│ │ └── events.py # SSE 실시간 이벤트 버스
│ ├── routers/
│ │ ├── tasks.py # SR CRUD + 상태 전이
│ │ ├── approvals.py # PM 승인 워크플로우
│ │ ├── dashboard.py # 대시보드 통계 + SSE + 7일 추이
│ │ ├── cmdb.py # CMDB 서버 자산 조회
│ │ ├── kb.py # 기술 문서 지식베이스
│ │ ├── assign.py # 엔지니어 자동 배정
│ │ ├── ai_cmd.py # AI 자연어 명령 인터페이스
│ │ ├── institutions.py # 기관/사이트 + 담당자 관리 (신규)
│ │ ├── servers.py # 서버 자산 확장 관리 (신규)
│ │ ├── shell_scripts.py # 쉘 스크립트 라이브러리 CRUD (신규)
│ │ └── timetable.py # 작업 타임테이블 + Excel 다운로드 (신규)
│ └── static/
│ ├── index.html # SPA 진입점
│ ├── app.js # 프론트엔드 로직 (64 KB)
│ └── style.css # Nifty 다크 테마 CSS
├── skills/
│ ├── guardia-deploy/SKILL.md # 배포 엔진 구현 스킬
│ ├── guardia-agent/SKILL.md # Python 역방향 에이전트 스킬
│ └── guardia-messenger/SKILL.md # 메신저 연동 스킬
└── src/ (생성 예정)
├── api/ # FastAPI 백엔드
├── agent/ # Python 역방향 에이전트
├── llm/ # sLLM 파서 모듈
├── deploy/ # SSH/SFTP 배포 엔진
└── db/ # DB 마이그레이션 & 모델
```
---
## 기술 스택 (변경 금지)
| 레이어 | 기술 | 비고 |
|--------|------|------|
| Backend API | Python 3.11+ / FastAPI | 비동기 WebSocket 처리 |
| LLM | 온프레미스 sLLM (Llama-3-8B / Solar-10.7B) | **외부 API 호출 절대 금지** |
| Infra 연결 | `paramiko` (SSH/SFTP) | 에이전트리스 |
| Database | PostgreSQL (CMDB + SR + Audit) | |
| 배포 자동화 | 쉘 스크립트 + Ansible (선택) | |
| 프론트 | React.js 또는 HTML5/Vanilla JS | |
---
## 핵심 구현 원칙
1. **에이전트리스**: 대상 서버에 어떤 소프트웨어도 설치하지 않는다.
2. **결정론적 파싱**: sLLM은 JSON만 출력한다. 자연어 부연 설명 금지.
3. **Fail-Safe**: 모든 배포는 백업 → 배포 → 헬스체크 → 롤백 시퀀스를 따른다.
4. **감사 추적**: 모든 명령과 결과는 `TB_AUDIT_LOG`에 기록한다.
5. **최소 권한**: 관제 전용 일반 계정(opsagent) 사용. root SSH 직접 접속 금지.
6. **보안 우선**: 서버 자격증명은 암호화 DB에만 저장. 메신저 응답에 노출 금지.
---
## 작업 시작 순서 (권장)
```
1단계: docs/db_schema.md 읽기 → PostgreSQL DDL 작성
2단계: docs/messenger_integration.md 읽기 → FastAPI 웹훅 서버 구현
3단계: docs/deployment_engine.md 읽기 → SSH/SFTP 배포 엔진 구현
4단계: docs/ai_orchestration.md 읽기 → sLLM 파서 & 워크플로우 연동
5단계: docs/security_governance.md 읽기 → 권한 검증 & 감사 모듈 구현
6단계: docs/site_user_management.md 읽기 → 기관/담당자/서버 자산 확장 구현
7단계: docs/shell_scripts_guide.md 읽기 → 쉘 스크립트 DB 관리 구현
8단계: docs/work_timetable.md 읽기 → 타임테이블 + Excel 다운로드 구현
```
---
## Workspace 소스 분석 워크플로우
**사용법:**
1. `C:\GUARDiA\workspace\<프로젝트명>\` 폴더에 소스코드를 넣는다
2. Claude에게 "workspace에 소스 넣었어" 또는 "분석해줘" 라고 말한다
3. `workspace-analyzer` 스킬이 자동으로:
- 기술스택 탐지 (Java/Python/Node.js/PHP 등)
- 개발환경 설치 가이드 제공
- `.claude/` 하네스 자동 생성 (에이전트 + 스킬)
- `CLAUDE.md` 자동 생성
**트리거:** `workspace-analyzer` 스킬을 사용하라 — "소스 분석", "workspace", "개발환경 가이드", "하네스 적용" 요청 시.
---
## 하네스: GUARDiA ITSM
**목표:** SR 접수·배포·코드리뷰·SLA·인시던트·RCA·보안패치 등 ITSM 운영 전반 자동화
**트리거:** ITSM 운영 관련 작업 요청 시 `guardia-orchestrator` 스킬을 사용하라.
단순 질문(API 경로, 모델 설명 등)은 직접 응답 가능.
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-05-20 | 초기 하네스 구성 | 전체 | GUARDiA ITSM 30개 고도화 항목 완료 |
| 2026-05-29 | G-1~G-12 확장 기능 구현 | 오케스트레이터, sr-manager, incident-responder, deploy-engineer | 메신저봇/대량처리/자동RCA/영향분석/AI분류/패치추적/Jira/PWA/다중승인/PostgreSQL |
| 2026-05-29 | 봇 명령어 확장 (/sr /status /license /bulk) | messenger.py | 슬래시 스타일 명령어 추가 |
| 2026-05-29 | 설치 스크립트 추가 | setup/ | Ubuntu/CentOS/RHEL/Windows 설치 자동화 |
| 2026-05-31 | DR·네트워크·CSAP 3종 추가 | dr-coordinator, network-guardian, csap-auditor + 스킬 3종 + 라우터 3종 | DR자동화/네트워크장비관리/CSAP자동점검 |
---
## 하네스: CI/CD 파이프라인
**목표:** Jenkins + Gitea webhook + deploy_server.py 기반 5개 repo 완전 자동화 파이프라인. 빌드-테스트-배포-롤백-알림 전 단계 구축.
**트리거:** CI/CD 파이프라인, Jenkins 설정, Jenkinsfile 작성, 빌드 자동화, 배포 자동화 요청 시 `cicd-pipeline-orchestrator` 스킬을 사용하라.
**현재 인프라:**
- Gitea webhook → port 9999 (deploy_server.py) ✅
- Jenkins port 8080 설치됨, 초기 설정 미완 ⚠️
- 5개 독립 repo (workspace/) ✅
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-01 | 초기 하네스 구성 | 전체 | CI/CD 파이프라인 구축 |
---
## 하네스: GUARDiA Manager
**목표:** GUARDiA ITSM·홈페이지·서버 인프라·CI/CD 통합 관제 관리자 포털 구축
**참조 디자인:** 네이버 클라우드 콘솔(NCloud Console) 패턴 적용.
**메인화면:** 대시보드 차트 중심 (SR 추이·서버 상태·리소스·배포 이력).
**트리거:** `C:\GUARDiA\manager` 관련 작업 요청 시 `manager-orchestrator` 스킬을 사용하라.
`M-01 대시보드`, `관리자 UI`, `Manager 배포`, `다시 실행`, `업데이트` 요청 시 포함.
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-05-30 | 초기 하네스 구성 | 전체 | GUARDiA Manager 신규 구축 |
| 2026-05-30 | 라이선스·Export-Import·AI플랫폼·GUARDiA CI-CD·SMTP 구축 | 다수 | 추가 기능 완료 |
---
## 하네스: workspace 통합 재구성
**목표:** itsm/, manager/, app/, manual/을 workspace/ 하위로 통합. git mv로 히스토리 보존, 모든 경로 참조 업데이트.
**트리거:** workspace로 이동, 소스 workspace 통합, 프로젝트별 workspace 정리 요청 시 `workspace-reorganize-orchestrator` 스킬을 사용하라.
**목표 구조:**
```
workspace/
├── zioinfo-web/ (현재 위치 유지)
├── guardia-itsm/ ← itsm/
├── guardia-manager/ ← manager/
├── guardia-messenger/ ← app/
└── guardia-docs/ ← manual/
```
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-05-31 | 초기 하네스 구성 | 전체 | workspace 통합 요청 |
---
## 하네스: 레파지토리 분리
**목표:** C:\GUARDiA 모노레포를 4개 독립 Gitea 저장소로 분리. GitHub 제거, Gitea 전용 운영.
**트리거:** 레파지토리 분리, 저장소 분리, repo 분리, GitHub 제거, Gitea 전용 운영 요청 시 `repo-split-orchestrator` 스킬을 사용하라.
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-05-31 | 초기 하네스 구성 | 전체 | 모노레포 → 독립 repo 전환 요청 |
---
## 하네스: UI 전면 개편
**목표:** Playwright MCP + Variant(variant.com/community)로 zio 4개 시스템(홈페이지·ITSM·Manager·Messenger) UI를 전면 개편. Before/After 시각적 비교 + 통합 디자인 토큰 적용.
**트리거:** UI 개편, 디자인 전면 개편, Variant 활용, 디자인 토큰, Before/After 비교, 컴포넌트 리팩토링 요청 시 `ui-overhaul-orchestrator` 스킬을 사용하라.
**메신저 봇 명령어 (`/design`):**
```
/design capture → Playwright MCP로 현재 UI 스크린샷 캡처
/design variant <검색어> → Variant에서 디자인 레퍼런스 탐색
/design tokens → 통합 tokens.css 생성
/design <시스템> → 특정 시스템 컴포넌트 개편 (homepage/itsm/manager/app)
/design qa → Before/After 시각적 QA
/design ab <컴포넌트> → A/B 테스트 컴포넌트 생성
```
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-05-31 | 초기 하네스 구성 | 전체 | 99.디자인전면개편.md 기반 |
---
## 하네스: GUARDiA 풀스택 통합
**목표:** GUARDiA ITSM·zioinfo-web·Manager·Messenger 4개 시스템을 단일 오케스트레이터로 연결. 크로스 시스템 신기능 추가·API 계약 관리·통합 QA 자동화.
**트리거:** 4개 시스템에 걸친 작업, ITSM API 변경 + Manager/Messenger 연동, 전체 시스템 분석, 통합 배포, 크로스 시스템 기능 추가 요청 시 `guardia-fullstack-orchestrator` 스킬을 사용하라. 단일 시스템 작업도 영향 범위 분석이 필요하면 사용하라.
**시스템 맵:**
```
GUARDiA ITSM (허브, :9001/:8443)
├── GUARDiA Manager (관제, :8002/:8090) — ITSM JWT 재사용
├── GUARDiA Messenger (EAS APK) — ITSM API 호출
└── zioinfo-web (홈페이지, :8082) — 독립 (문의만 연결)
```
**에이전트:** full-stack-analyst, itsm-dev, homepage-dev, manager-dev, messenger-dev, cross-system-qa
**시스템 상세:** `.claude/skills/guardia-fullstack-orchestrator/references/system-landscape.md`
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-01 | 초기 하네스 구성 | 전체 | 4개 시스템 전체 분석 + 마스터 하네스 생성 |
---
## 하네스: GUARDiA 기능 개선 및 추가
**목표:** 기존 기능 UX 개선 + 5개 신규 기능. 핵심: 모바일 앱 QR 코드 직접 배포(앱스토어 불필요), ITSM 준비중 뷰 8개 완성, 웹메일 주소록·서명·폴더, 자산 QR 태그, 알림 규칙 노코드 편집기.
**트리거:** 앱 QR 배포, APK 직접 배포, ITSM 개선, 배치 SSH, 웹메일 주소록, 자산 QR, 알림 규칙 편집기 요청 시 `guardia-enhance-orchestrator` 스킬 사용.
**에이전트:**
- `app-distribution-dev` — APK 업로드→QR 생성→랜딩 페이지 (Manager + ITSM)
- `itsm-ux-dev` — 준비중 뷰 8개 완성 + 배치 SSH + D3 의존성 맵
- `mail-enhance-dev` — 주소록·서명·폴더 관리 (zioinfo-mail)
- `asset-qr-dev` — 서버 QR 태그·스캔·CMDB 조회·실사 체크인
- `notification-ui-dev` — 노코드 알림 규칙 편집기 + 스마트 필터
**QR 앱 배포 흐름:** Manager에서 APK 업로드 → QR 자동 생성 → 사용자 QR 스캔 → 다운로드 랜딩 페이지 → APK 설치 (Play Store 불필요)
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-02 | 초기 하네스 구성 | 전체 | 기존 기능 개선 + QR 배포 등 5개 신규 기능 |
---
## 하네스: Upstage OCR 연동
**목표:** Upstage Document AI API(Document Parse·Information Extraction·Document QA)를 연동하여 계약서·납품서·청구서·장애보고서·감사보고서·회의록을 자동 처리하고 ITSM 기능에 연동. 현대백화점 등 기업 브랜드 계약서 포함.
**트리거:** OCR, Upstage, 문서 파싱, 계약서 자동 처리, 현대백화점 계약, 브랜드 계약서, 납품서 CMDB 등록, 청구서 자동 처리, 장애보고서 이미지→SR 요청 시 `upstage-ocr-orchestrator` 스킬을 사용하라.
**에이전트:** upstage-ocr-dev (Document AI API 엔진) · ocr-workflow-dev (6개 워크플로우 + 브랜드 계약 연동)
**신규 라우터:** upstage_ocr.py · doc_workflow.py · doc_template.py
**지원 시나리오:**
1. 나라장터 계약서 → ProcurementRecord 자동 등록
2. 서버납품서 → CMDB 자동 등록
3. 브랜드 계약서 (현대백화점 등) → 계약 이력 관리
4. 세금계산서 → 과금 연동
5. 장애보고서 이미지 → SR 자동 생성
6. 회의록 → 액션아이템 SR 생성
7. CSAP 보고서 → 준수율 자동 업데이트
**API 가이드:** `.claude/skills/upstage-ocr-orchestrator/references/upstage-api-guide.md`
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-02 | 초기 하네스 구성 | 전체 | Upstage OCR 연동 + 기업 계약서 처리 |
---
## 하네스: GUARDiA 고급 확장
**목표:** GUARDiA ITSM 현재 104개 라우터(667 엔드포인트)에서 20개 신규 라우터 추가. CMDB 자동 발견·Text-to-SQL·구성 드리프트·멀티클라우드·공공기관 특화 5개 영역 확장. 목표: 124개 라우터, ~764개 엔드포인트.
**트리거:** CMDB 자동 발견, 자연어 쿼리, 구성 드리프트, 멀티클라우드, 나라장터/공공API/ISP/K-Cloud 요청 시 `guardia-advanced-orchestrator` 스킬을 사용하라.
**에이전트:** cmdb-autodiscovery-dev · nlquery-dev · config-drift-dev · multicloud-dev · public-sector-dev
**분석 근거:**
- CMDB: 수동 등록만 → 자동 발견으로 커버리지 100%
- Text-to-SQL: API/UI만 → 운영자 자연어 접근
- 드리프트: 설정 변경 미감지 → 보안·규정 위반 즉시 탐지
- 멀티클라우드: NCloud만 → 공공기관 멀티클라우드 전략 대응
- 공공기관: 기본 CSAP만 → 국내 공공 ITSM 시장 차별화
**로드맵:** `.claude/skills/guardia-advanced-orchestrator/references/advanced-roadmap.md`
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-02 | 초기 하네스 구성 | 전체 | GUARDiA 추가·확장 기능 분석 후 5개 영역 선정 |
---
## 하네스: GUARDiA 플랫폼 확장
**목표:** GUARDiA ITSM 81개 라우터에서 25개 신규 라우터 추가. 클라우드/컨테이너·AI 고도화·멀티테넌트 SaaS·엔터프라이즈 통합·BI 5개 영역 확장.
**트리거:** GUARDiA 확장, 신규 기능 추가, 고도화 요청 시 `guardia-expansion-orchestrator` 스킬을 사용하라. K8s/Docker/Jira/Slack/KPI/RAG/SaaS/화이트라벨/구독 관련 모든 요청 포함.
**에이전트:** cloud-container-dev · ai-platform-dev · saas-platform-dev · enterprise-integrator · bi-analytics-dev
**로드맵:** `.claude/skills/guardia-expansion-orchestrator/references/expansion-roadmap.md`
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-01 | 초기 하네스 구성 | 전체 | GUARDiA 플랫폼 확장 5개 영역 |
---
## 하네스: zioinfo-mail 웹메일 시스템
**목표:** 지오정보기술 Postfix/Dovecot SMTP 서버를 활용한 React+FastAPI 웹메일 클라이언트 구축. `mail.zioinfo.co.kr:8025`, IMAP/SMTP 연동, 3-패널 메일 UI.
**트리거:** 웹메일, zioinfo-mail, 메일 클라이언트, IMAP/SMTP 연동 요청 시 `zioinfo-mail-orchestrator` 스킬을 사용하라.
**에이전트:** mail-backend-dev (FastAPI IMAP/SMTP 프록시), mail-frontend-dev (React SPA), mail-infra-setup (nginx/systemd/배포)
**인프라:** Postfix(25/587) + Dovecot(143/993) 기운영 중 | 계정: ythong/info/admin @zioinfo.co.kr
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-01 | 초기 하네스 구성 | 전체 | zioinfo SMTP 기반 웹메일 구축 |
---
## 하네스: 5개 시스템 배포 동기화
**목표:** guardia-itsm·zioinfo-web·guardia-manager·guardia-messenger·guardia-docs 5개 시스템의 workspace↔repos↔Gitea↔서버 4-way 동기화 상태를 검증하고 이슈를 자동 수정한다.
**트리거:** 배포 상태 확인, 서버 동기화, 최신본 확인 요청 시 `system-sync-orchestrator` 스킬을 사용하라. "5개 시스템", "배포 확인", "서버 최신", "동기화", "전체 확인" 요청 포함.
**에이전트:** deploy-verifier (검증), deploy-fixer (수정)
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-01 | 초기 하네스 구성 | 전체 | 5개 시스템 배포 상태 점검 자동화 |
---
## 하네스: 폴더 정리
**목표:** 루트에 쌓이는 임시 Python 스크립트·구버전 소스·로그 파일을 용도별로 분류·이동·아카이브.
**트리거:** 폴더 정리, 루트 정리, 파일 정리, 스크립트 정리 요청 시 `folder-cleanup-orchestrator` 스킬을 사용하라.
**현재 구조 (2026-06-01 기준):**
```
scripts/deploy/ (26개) scripts/check/ (16개)
scripts/push/ (6개) scripts/setup/ (13개) scripts/misc/ (21개)
_archive/ (backend/ frontend/ messenger/ 구버전)
```
**변경 이력:**
| 날짜 | 변경 내용 | 대상 | 사유 |
|------|----------|------|------|
| 2026-06-01 | 초기 폴더 정리 | 루트 82개 파일 → scripts/, docs/, _archive/ | 루트 산재 정리 |
---
## 보안 제약 (불변)
> 아래 규칙은 어떤 상황에서도 위반 불가
| 규칙 | 내용 |
|------|------|
| 외부 API 금지 | on-premise sLLM(Ollama)만 허용. 외부 호출 절대 금지 |
| 자격증명 보호 | IP, SSH계정, 비밀번호를 API 응답/메신저/에러메시지에 절대 노출 금지 |
| 암호화 필수 | `os_pw_enc` 컬럼 AES-256-GCM 암호화 저장 필수 |
| root 금지 | root SSH 직접 접속 금지 — opsagent 전용 계정 사용 |
| 에러 응답 | 스택트레이스 미노출 — SR ID + 요약 메시지만 전달 |
| ServerOut 스키마 | `ip_addr`, `ssh_user`, `os_pw_enc` 컬럼 API 응답에서 완전 제외 |
---
## 스킬 파일 참조 방법
특정 기능 구현 전 해당 스킬 파일을 반드시 먼저 읽어라.
- 배포 엔진 작업 시 → `skills/guardia-deploy/SKILL.md`
- 역방향 에이전트 작업 시 → `skills/guardia-agent/SKILL.md`
- 메신저 연동 작업 시 → `skills/guardia-messenger/SKILL.md`

54
Dockerfile
View File

@ -1,54 +0,0 @@
# ============================================================
# GUARDiA ITSM — Production Dockerfile
# Base: Python 3.11-slim
# Port: 8001
# ============================================================
FROM python:3.11-slim AS base
LABEL maintainer="GUARDiA Team"
LABEL description="GUARDiA ITSM — AI 기반 레거시 인프라 자율 운영 플랫폼"
# ── 시스템 의존성 ──────────────────────────────────────────
RUN apt-get update && apt-get install -y --no-install-recommends \
curl wget git \
libpq-dev gcc \
&& rm -rf /var/lib/apt/lists/*
# ── 비루트 실행 계정 ───────────────────────────────────────
RUN groupadd -r guardia && useradd -r -g guardia -d /app guardia
# ── 작업 디렉토리 ─────────────────────────────────────────
WORKDIR /app
# ── Python 의존성 (레이어 캐싱 최적화) ─────────────────────
COPY itsm/requirements.txt .
RUN pip install --no-cache-dir --upgrade pip \
&& pip install --no-cache-dir -r requirements.txt
# ── 애플리케이션 소스 복사 ───────────────────────────────
COPY itsm/ .
# ── 업로드/데이터 디렉토리 ──────────────────────────────
RUN mkdir -p uploads/sr_files uploads/workspaces \
&& chown -R guardia:guardia /app
# ── 환경 기본값 ──────────────────────────────────────────
ENV PYTHONUNBUFFERED=1 \
PYTHONIOENCODING=utf-8 \
PYTHONDONTWRITEBYTECODE=1 \
DATABASE_URL="sqlite+aiosqlite:///./guardia_itsm.db" \
OLLAMA_BASE_URL="http://ollama:11434"
# ── 포트 노출 ────────────────────────────────────────────
EXPOSE 8001
# ── 비루트 전환 ─────────────────────────────────────────
USER guardia
# ── 헬스체크 ─────────────────────────────────────────────
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
CMD curl -sf http://localhost:8001/ || exit 1
# ── 엔트리포인트 ─────────────────────────────────────────
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8001", "--workers", "4"]

0
workspace/zioinfo-mail/Jenkinsfile → Jenkinsfile vendored
View File

108
_archive/Jenkinsfile vendored
View File

@ -1,108 +0,0 @@
pipeline {
agent any
environment {
DEPLOY_DIR = '/var/www/zioinfo'
APP_DIR = '/opt/zioinfo/app'
JAVA_HOME = '/usr/lib/jvm/java-21-openjdk-amd64'
MVN = '/usr/bin/mvn'
NODE_HOME = '/usr/bin'
}
options {
buildDiscarder(logRotator(numToKeepStr: '5'))
timeout(time: 20, unit: 'MINUTES')
}
stages {
stage('Checkout') {
steps {
echo "브랜치: ${env.GIT_BRANCH ?: 'main'} | 커밋: ${env.GIT_COMMIT?.take(7) ?: '-'}"
checkout([
$class: 'GitSCM',
branches: scm.branches,
userRemoteConfigs: scm.userRemoteConfigs,
extensions: [
// manual/ 폴더 체크아웃 제외 (배포 대상 아님)
[$class: 'SparseCheckoutPaths', sparseCheckoutPaths: [
[path: 'frontend'],
[path: 'backend'],
]]
]
])
}
}
stage('Frontend Build') {
steps {
dir('frontend') {
sh '''
echo "=== [1/3] React 빌드 ==="
npm ci --legacy-peer-deps --prefer-offline 2>/dev/null || npm install --legacy-peer-deps
npm run build
echo "빌드 결과: $(ls ../backend/src/main/resources/static/assets/ | wc -l) 파일"
'''
}
}
}
stage('Backend Build') {
steps {
dir('backend') {
sh '''
echo "=== [2/3] Spring Boot 빌드 ==="
${MVN} clean package -DskipTests -q
JAR=$(find target -name "*.jar" ! -name "*sources*" | head -1)
echo "JAR: $JAR ($(du -sh $JAR | cut -f1))"
'''
}
}
}
stage('Deploy') {
steps {
sh '''
echo "=== [3/3] 배포 ==="
JAR=$(find backend/target -name "*.jar" ! -name "*sources*" | head -1)
# 앱 디렉터리 확인
mkdir -p ${APP_DIR} ${DEPLOY_DIR}
# JAR 배포
cp "$JAR" ${APP_DIR}/app.jar
# React 정적 파일 배포
cp -r backend/src/main/resources/static/. ${DEPLOY_DIR}/
# Spring Boot 서비스 재시작
systemctl restart zioinfo || true
sleep 4
# 헬스체크
for i in 1 2 3 4 5; do
HTTP=$(curl -s -o /dev/null -w "%{http_code}" http://localhost:8080/api/company 2>/dev/null)
if [ "$HTTP" = "200" ]; then
echo "배포 성공 (Spring Boot HTTP $HTTP)"
exit 0
fi
echo "헬스체크 ${i}/5 대기중 (HTTP: $HTTP)..."
sleep 3
done
echo "경고: Spring Boot 응답 없음 — 서비스 상태 확인 필요"
'''
}
}
}
post {
success {
echo "✅ 배포 완료: ${currentBuild.displayName} (${currentBuild.durationString})"
}
failure {
echo "❌ 배포 실패: ${currentBuild.displayName} — 로그 확인 필요"
}
always {
cleanWs(cleanWhenNotBuilt: false, cleanWhenSuccess: false)
}
}
}

2
_archive/backend/.mvn/wrapper/maven-wrapper.properties vendored
View File

@ -1,2 +0,0 @@
distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.6/apache-maven-3.9.6-bin.zip
wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar

126
_archive/backend/pom.xml
View File

@ -1,126 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.2.5</version>
<relativePath/>
</parent>
<groupId>kr.co.zioinfo</groupId>
<artifactId>zioinfo-web</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>
<name>ZioInfo Web</name>
<description>(주)지오정보기술 기업 홈페이지</description>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<!-- Spring Boot Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring Data JPA -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- SQLite (기본 DB — 파일 기반, 설치 없음) -->
<dependency>
<groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId>
<version>3.45.3.0</version>
</dependency>
<!-- SQLite Hibernate Dialect (hibernate-community-dialects) -->
<dependency>
<groupId>org.hibernate.orm</groupId>
<artifactId>hibernate-community-dialects</artifactId>
</dependency>
<!-- MySQL (운영 환경 전환 시 사용) -->
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
<scope>runtime</scope>
<optional>true</optional>
</dependency>
<!-- Validation -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<!-- Mail (문의 이메일 발송) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
<!-- Spring Security -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<!-- JWT -->
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>0.12.3</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>0.12.3</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>0.12.3</version>
<scope>runtime</scope>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- Test -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>

13
_archive/backend/src/main/java/kr/co/zioinfo/web/ZioinfoWebApplication.java
View File

@ -1,13 +0,0 @@
package kr.co.zioinfo.web;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
@SpringBootApplication
@EnableJpaAuditing
public class ZioinfoWebApplication {
public static void main(String[] args) {
SpringApplication.run(ZioinfoWebApplication.class, args);
}
}

97
_archive/backend/src/main/java/kr/co/zioinfo/web/config/DataInitializer.java
View File

@ -1,97 +0,0 @@
package kr.co.zioinfo.web.config;
import kr.co.zioinfo.web.model.*;
import kr.co.zioinfo.web.repository.*;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.CommandLineRunner;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Component;
import java.time.LocalDate;
@Component
@RequiredArgsConstructor
public class DataInitializer implements CommandLineRunner {
private final NewsRepository newsRepo;
private final AdminUserRepository adminUserRepo;
private final RecruitRepository recruitRepo;
private final PasswordEncoder passwordEncoder;
@Override
public void run(String... args) {
initAdmin();
initNews();
initRecruits();
}
private void initAdmin() {
if (adminUserRepo.existsByUsername("admin")) return;
adminUserRepo.save(AdminUser.builder()
.username("admin")
.password(passwordEncoder.encode("Admin@2026!"))
.displayName("관리자")
.email("admin@zioinfo.co.kr")
.enabled(true)
.build());
}
private void initNews() {
if (newsRepo.count() > 0) return;
newsRepo.save(News.builder()
.title("GUARDiA ITSM 2.0 정식 출시 — AI 기반 인프라 자율 운영 플랫폼")
.category("보도자료")
.summary("(주)지오정보기술이 공공기관 레거시 인프라 자동화를 위한 GUARDiA ITSM 2.0을 정식 출시했습니다.")
.content("GUARDiA ITSM 2.0은 메신저 한 줄 명령으로 에이전트리스 SSH/SFTP 배포·운영을 자동화하는 온프레미스 플랫폼입니다.")
.visible(true).viewCount(128).build());
newsRepo.save(News.builder()
.title("2026 공공기관 AI 인프라 혁신 박람회 참가")
.category("공지사항")
.summary("지오정보기술이 2026 공공기관 AI 인프라 혁신 박람회에 참가하여 GUARDiA 솔루션을 선보입니다.")
.content("박람회 기간: 2026년 6월 15일~17일 / 장소: 코엑스 A홀 / 부스: A-215")
.visible(true).viewCount(87).build());
newsRepo.save(News.builder()
.title("행정안전부 공공SW 우수제품 선정")
.category("보도자료")
.summary("GUARDiA ITSM이 행정안전부 2026년 공공SW 우수제품으로 선정되었습니다.")
.content("행정안전부는 공공기관 정보화 사업에 적합한 소프트웨어를 심사하여 우수제품을 선정합니다.")
.visible(true).viewCount(214).build());
newsRepo.save(News.builder()
.title("특허 등록 — 에이전트리스 레거시 인프라 자동화 방법")
.category("공지사항")
.summary("에이전트 설치 없이 SSH/SFTP 프로토콜만으로 레거시 WAS를 자동화하는 방법에 대한 특허가 등록되었습니다.")
.content("특허명: 에이전트리스 레거시 인프라 자동화 시스템 및 방법\n등록번호: 10-2026-XXXXXXX")
.visible(true).viewCount(41).build());
}
private void initRecruits() {
if (recruitRepo.count() > 0) return;
recruitRepo.save(Recruit.builder()
.title("백엔드 개발자 (Java/Spring Boot)")
.department("개발팀").jobType("정규직")
.description("- GUARDiA ITSM 백엔드 API 개발\n- 성능 최적화 및 코드 리뷰\n- 공공기관 SI 프로젝트 참여")
.requirements("- Spring Boot 실무 경력 3년 이상\n- JPA/Hibernate 경험\n- RESTful API 설계 능력")
.preferred("- 공공기관 프로젝트 경험\n- MSA 아키텍처 이해\n- 보안 코딩 경험")
.deadline(LocalDate.of(2026, 6, 30)).headcount(2).active(true).build());
recruitRepo.save(Recruit.builder()
.title("프론트엔드 개발자 (React)")
.department("개발팀").jobType("정규직")
.description("- React SPA 개발 및 유지보수\n- 홈페이지 및 관리자 페이지 개발\n- UI/UX 개선")
.requirements("- React 실무 경력 2년 이상\n- JavaScript/TypeScript 능숙\n- CSS 레이아웃 및 반응형 웹 경험")
.preferred("- 공공기관 프로젝트 경험\n- 데이터 시각화 경험 (Chart.js 등)")
.deadline(LocalDate.of(2026, 6, 30)).headcount(1).active(true).build());
recruitRepo.save(Recruit.builder()
.title("인프라 엔지니어 (Linux/DevOps)")
.department("인프라팀").jobType("정규직")
.description("- 공공기관 서버 인프라 구축 및 운영\n- CI/CD 파이프라인 관리\n- 보안 취약점 점검")
.requirements("- Linux 서버 운영 경력 3년 이상\n- Ansible/Terraform 경험\n- 네트워크 기초 지식")
.preferred("- 공공기관 정보보호 인증 자격증 (정보처리기사 등)\n- Kubernetes 경험")
.deadline(LocalDate.of(2026, 7, 31)).headcount(1).active(true).build());
}
}

61
_archive/backend/src/main/java/kr/co/zioinfo/web/config/SecurityConfig.java
View File

@ -1,61 +0,0 @@
package kr.co.zioinfo.web.config;
import kr.co.zioinfo.web.security.JwtAuthFilter;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import java.util.List;
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
public class SecurityConfig {
private final JwtAuthFilter jwtAuthFilter;
@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
return http
.csrf(AbstractHttpConfigurer::disable)
.cors(cors -> cors.configurationSource(corsConfigurationSource()))
.sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth
.requestMatchers(HttpMethod.POST, "/api/admin/login").permitAll()
.requestMatchers("/api/admin/**").hasRole("ADMIN")
.requestMatchers(HttpMethod.GET, "/api/**").permitAll()
.requestMatchers(HttpMethod.POST, "/api/inquiry").permitAll()
.requestMatchers("/", "/**").permitAll()
.anyRequest().authenticated())
.addFilterBefore(jwtAuthFilter, UsernamePasswordAuthenticationFilter.class)
.build();
}
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
@Bean
public CorsConfigurationSource corsConfigurationSource() {
CorsConfiguration cfg = new CorsConfiguration();
cfg.setAllowedOriginPatterns(List.of("*"));
cfg.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS"));
cfg.setAllowedHeaders(List.of("*"));
cfg.setAllowCredentials(true);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", cfg);
return source;
}
}

182
_archive/backend/src/main/java/kr/co/zioinfo/web/controller/AdminController.java
View File

@ -1,182 +0,0 @@
package kr.co.zioinfo.web.controller;
import kr.co.zioinfo.web.model.*;
import kr.co.zioinfo.web.repository.*;
import kr.co.zioinfo.web.security.JwtUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.*;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@RestController
@RequestMapping("/api/admin")
@RequiredArgsConstructor
public class AdminController {
private final AdminUserRepository adminUserRepo;
private final NewsRepository newsRepo;
private final InquiryRepository inquiryRepo;
private final RecruitRepository recruitRepo;
private final JwtUtil jwtUtil;
private final PasswordEncoder passwordEncoder;
// ── 로그인 ────────────────────────────────────────────────
@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody Map<String, String> body) {
String username = body.get("username");
String password = body.get("password");
return adminUserRepo.findByUsername(username)
.filter(u -> u.isEnabled() && passwordEncoder.matches(password, u.getPassword()))
.map(u -> ResponseEntity.ok(Map.of(
"token", jwtUtil.generate(u.getUsername()),
"username", u.getUsername(),
"displayName", Optional.ofNullable(u.getDisplayName()).orElse(u.getUsername()))))
.orElse(ResponseEntity.status(401).body(Map.of("message", "아이디 또는 비밀번호가 올바르지 않습니다.")));
}
// ── 대시보드 통계 ────────────────────────────────────────
@GetMapping("/dashboard")
public ResponseEntity<Map<String, Object>> dashboard() {
Map<String, Object> stats = new LinkedHashMap<>();
stats.put("totalNews", newsRepo.count());
stats.put("visibleNews", newsRepo.countByVisibleTrue());
stats.put("totalInquiries", inquiryRepo.count());
stats.put("pendingInquiries", inquiryRepo.countByStatus("PENDING"));
stats.put("totalRecruits", recruitRepo.count());
stats.put("activeRecruits", recruitRepo.countByActiveTrue());
stats.put("recentInquiries", inquiryRepo.findTop5ByOrderByCreatedAtDesc());
stats.put("recentNews", newsRepo.findTop5ByOrderByCreatedAtDesc());
return ResponseEntity.ok(stats);
}
// ── 뉴스 관리 ────────────────────────────────────────────
@GetMapping("/news")
public ResponseEntity<Page<News>> adminNews(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size) {
return ResponseEntity.ok(newsRepo.findAll(
PageRequest.of(page, size, Sort.by("createdAt").descending())));
}
@PostMapping("/news")
public ResponseEntity<News> createNews(@RequestBody News news) {
news.setId(null);
news.setCreatedAt(null);
return ResponseEntity.ok(newsRepo.save(news));
}
@PutMapping("/news/{id}")
public ResponseEntity<?> updateNews(@PathVariable Long id, @RequestBody News body) {
return newsRepo.findById(id).map(n -> {
n.setTitle(body.getTitle());
n.setCategory(body.getCategory());
n.setContent(body.getContent());
n.setSummary(body.getSummary());
n.setThumbnailUrl(body.getThumbnailUrl());
n.setVisible(body.isVisible());
return ResponseEntity.ok(newsRepo.save(n));
}).orElse(ResponseEntity.notFound().build());
}
@DeleteMapping("/news/{id}")
public ResponseEntity<Void> deleteNews(@PathVariable Long id) {
if (!newsRepo.existsById(id)) return ResponseEntity.notFound().build();
newsRepo.deleteById(id);
return ResponseEntity.noContent().build();
}
@PatchMapping("/news/{id}/visibility")
public ResponseEntity<?> toggleVisibility(@PathVariable Long id) {
return newsRepo.findById(id).map(n -> {
n.setVisible(!n.isVisible());
return ResponseEntity.ok(newsRepo.save(n));
}).orElse(ResponseEntity.notFound().build());
}
// ── 문의 관리 ────────────────────────────────────────────
@GetMapping("/inquiries")
public ResponseEntity<Page<Inquiry>> adminInquiries(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size,
@RequestParam(required = false) String status) {
Pageable pageable = PageRequest.of(page, size, Sort.by("createdAt").descending());
Page<Inquiry> result = (status != null && !status.isBlank())
? inquiryRepo.findByStatus(status, pageable)
: inquiryRepo.findAll(pageable);
return ResponseEntity.ok(result);
}
@GetMapping("/inquiries/{id}")
public ResponseEntity<Inquiry> getInquiry(@PathVariable Long id) {
return inquiryRepo.findById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}
@PatchMapping("/inquiries/{id}/status")
public ResponseEntity<?> updateInquiryStatus(
@PathVariable Long id, @RequestBody Map<String, String> body) {
return inquiryRepo.findById(id).map(i -> {
i.setStatus(body.getOrDefault("status", i.getStatus()));
return ResponseEntity.ok(inquiryRepo.save(i));
}).orElse(ResponseEntity.notFound().build());
}
// ── 채용공고 관리 ────────────────────────────────────────
@GetMapping("/recruits")
public ResponseEntity<Page<Recruit>> adminRecruits(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "10") int size) {
return ResponseEntity.ok(recruitRepo.findAllByOrderByCreatedAtDesc(
PageRequest.of(page, size)));
}
@PostMapping("/recruits")
public ResponseEntity<Recruit> createRecruit(@RequestBody Recruit recruit) {
recruit.setId(null);
recruit.setCreatedAt(null);
return ResponseEntity.ok(recruitRepo.save(recruit));
}
@PutMapping("/recruits/{id}")
public ResponseEntity<?> updateRecruit(@PathVariable Long id, @RequestBody Recruit body) {
return recruitRepo.findById(id).map(r -> {
r.setTitle(body.getTitle());
r.setDepartment(body.getDepartment());
r.setJobType(body.getJobType());
r.setDescription(body.getDescription());
r.setRequirements(body.getRequirements());
r.setPreferred(body.getPreferred());
r.setDeadline(body.getDeadline());
r.setHeadcount(body.getHeadcount());
r.setActive(body.isActive());
return ResponseEntity.ok(recruitRepo.save(r));
}).orElse(ResponseEntity.notFound().build());
}
@DeleteMapping("/recruits/{id}")
public ResponseEntity<Void> deleteRecruit(@PathVariable Long id) {
if (!recruitRepo.existsById(id)) return ResponseEntity.notFound().build();
recruitRepo.deleteById(id);
return ResponseEntity.noContent().build();
}
// ── 비밀번호 변경 ────────────────────────────────────────
@PutMapping("/password")
public ResponseEntity<?> changePassword(
@RequestBody Map<String, String> body,
jakarta.servlet.http.HttpServletRequest req) {
String authHeader = req.getHeader("Authorization");
String username = jwtUtil.extractUsername(authHeader.substring(7));
return adminUserRepo.findByUsername(username).map(u -> {
if (!passwordEncoder.matches(body.get("currentPassword"), u.getPassword()))
return ResponseEntity.badRequest().body(Map.of("message", "현재 비밀번호가 올바르지 않습니다."));
u.setPassword(passwordEncoder.encode(body.get("newPassword")));
adminUserRepo.save(u);
return ResponseEntity.ok(Map.of("message", "비밀번호가 변경되었습니다."));
}).orElse(ResponseEntity.notFound().build());
}
}

190
_archive/backend/src/main/java/kr/co/zioinfo/web/controller/ApiController.java
View File

@ -1,190 +0,0 @@
package kr.co.zioinfo.web.controller;
import kr.co.zioinfo.web.model.Inquiry;
import kr.co.zioinfo.web.model.News;
import kr.co.zioinfo.web.repository.RecruitRepository;
import kr.co.zioinfo.web.service.InquiryService;
import kr.co.zioinfo.web.service.NewsService;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.*;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import java.util.*;
@RestController
@RequestMapping("/api")
@RequiredArgsConstructor
public class ApiController {
private final NewsService newsService;
private final InquiryService inquiryService;
private final RecruitRepository recruitRepo;
// ── 회사 정보 ────────────────────────────────────────────────
@GetMapping("/company")
public ResponseEntity<Map<String, Object>> getCompanyInfo() {
Map<String, Object> info = new LinkedHashMap<>();
info.put("name", "(주)지오정보기술");
info.put("ceo", "대표이사");
info.put("founded", "2000년");
info.put("address", "서울특별시");
info.put("phone", "02-000-0000");
info.put("email", "info@zioinfo.co.kr");
info.put("business", Arrays.asList(
Map.of("name", "GUARDiA ITSM", "desc", "AI 기반 레거시 인프라 자율 운영 플랫폼"),
Map.of("name", "ERP 솔루션", "desc", "기업 자원관리 시스템"),
Map.of("name", "SI 구축", "desc", "정보화사업 시스템 통합"),
Map.of("name", "IT 인프라", "desc", "인프라 구축 및 운영")
));
return ResponseEntity.ok(info);
}
// ── 연혁 ─────────────────────────────────────────────────────
@GetMapping("/history")
public ResponseEntity<List<Map<String, Object>>> getHistory() {
List<Map<String, Object>> history = new ArrayList<>();
history.add(Map.of("year", "2026", "events", List.of(
"GUARDiA ITSM v2.0 출시 (AI 자율 운영 플랫폼)",
"공공기관 AI 인프라 자동화 사업 수주"
)));
history.add(Map.of("year", "2024", "events", List.of(
"GUARDiA ITSM v1.0 개발 완료",
"관공서 레거시 인프라 자동화 특허 출원"
)));
history.add(Map.of("year", "2022", "events", List.of(
"AI 기반 ChatOps 플랫폼 연구 개발 착수",
"행정기관 SI 사업 10건 수주"
)));
history.add(Map.of("year", "2020", "events", List.of(
"창립 20주년",
"클라우드 전환 컨설팅 사업 진출"
)));
history.add(Map.of("year", "2010", "events", List.of(
"ERP·CRM 솔루션 공급 100개사 달성"
)));
history.add(Map.of("year", "2000", "events", List.of(
"(주)지오정보기술 설립"
)));
return ResponseEntity.ok(history);
}
// ── GUARDiA 솔루션 정보 ───────────────────────────────────────
@GetMapping("/solutions/guardia")
public ResponseEntity<Map<String, Object>> getGuardiaInfo() {
Map<String, Object> g = new LinkedHashMap<>();
g.put("name", "GUARDiA ITSM");
g.put("tagline", "AI 기반 레거시 인프라 자율 운영 플랫폼");
g.put("description",
"1,000개 이상 관공서 레거시 인프라를 대상으로 하는 AI 기반 통합 ChatOps 오케스트레이션 플랫폼. " +
"메신저 한 줄 명령으로 에이전트리스 배포·운영을 자동화합니다.");
g.put("keyFeatures", Arrays.asList(
Map.of("icon", "🤖", "title", "AI 에이전트 자동화",
"desc", "Ollama 온프레미스 sLLM 기반 자연어 명령 → 자동 배포·운영"),
Map.of("icon", "🔧", "title", "에이전트리스 아키텍처",
"desc", "대상 서버에 소프트웨어 설치 없이 SSH/SFTP만으로 관리"),
Map.of("icon", "💬", "title", "ChatOps 메신저 통합",
"desc", "카카오워크·네이버웍스·슬랙 등 메신저에서 직접 인프라 제어"),
Map.of("icon", "📊", "title", "통합 ITSM 대시보드",
"desc", "SR·인시던트·변경관리·SLA·CMDB 전체를 하나의 플랫폼에서"),
Map.of("icon", "🔒", "title", "엔터프라이즈 보안",
"desc", "AES-256-GCM 암호화, MFA, PAM, 불변 감사로그, Zero Trust"),
Map.of("icon", "🏗️", "title", "PMS (프로젝트 관리)",
"desc", "WBS·산출물·일주월 보고서 자동 생성, 이슈·위험 관리")
));
g.put("editions", Arrays.asList(
Map.of("name", "COMMUNITY", "price", "무료", "target", "소규모 기관",
"features", List.of("기본 SR 관리", "CMDB", "대시보드")),
Map.of("name", "STANDARD", "price", "협의", "target", "중형 기관",
"features", List.of("전체 ITSM", "AI 에이전트", "LDAP/MFA", "SLA")),
Map.of("name", "ENTERPRISE", "price", "협의", "target", "대형 관공서",
"features", List.of("무제한", "취약점 스캔", "Scouter APM", "FinOps", "전담 지원"))
));
g.put("techStack", Map.of(
"backend", "Python 3.11 / FastAPI",
"ai", "Ollama (온프레미스 sLLM, 외부 API 완전 금지)",
"infra", "paramiko SSH/SFTP (에이전트리스)",
"db", "PostgreSQL / SQLite",
"frontend", "React.js / PWA"
));
return ResponseEntity.ok(g);
}
// ── 소식 목록 ────────────────────────────────────────────────
@GetMapping("/news")
public ResponseEntity<Page<News>> getNews(
@RequestParam(defaultValue = "0") int page,
@RequestParam(defaultValue = "6") int size,
@RequestParam(required = false) String category) {
Pageable pageable = PageRequest.of(page, size, Sort.by("createdAt").descending());
return ResponseEntity.ok(newsService.findAll(category, pageable));
}
@GetMapping("/news/{id}")
public ResponseEntity<News> getNewsDetail(@PathVariable Long id) {
return newsService.findById(id)
.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}
// ── 문의 접수 ────────────────────────────────────────────────
@PostMapping("/inquiry")
public ResponseEntity<Map<String, String>> submitInquiry(@Valid @RequestBody Inquiry inquiry) {
inquiryService.save(inquiry);
return ResponseEntity.ok(Map.of(
"message", "문의가 접수되었습니다. 빠른 시일 내에 연락드리겠습니다.",
"status", "SUCCESS"
));
}
// ── 채용공고 (공개) ───────────────────────────────────────────
@GetMapping("/recruits")
public ResponseEntity<?> getRecruits() {
return ResponseEntity.ok(recruitRepo.findByActiveTrueOrderByCreatedAtDesc());
}
// ── 메뉴 구조 ────────────────────────────────────────────────
@GetMapping("/menu")
public ResponseEntity<List<Map<String, Object>>> getMenu() {
return ResponseEntity.ok(List.of(
Map.of("id", "company", "label", "회사소개",
"children", List.of(
Map.of("id", "greeting", "label", "CEO 인사말", "path", "/company/greeting"),
Map.of("id", "history", "label", "연혁", "path", "/company/history"),
Map.of("id", "organization", "label", "조직도", "path", "/company/organization"),
Map.of("id", "ci", "label", "CI 소개", "path", "/company/ci"),
Map.of("id", "location", "label", "오시는 길", "path", "/company/location")
)),
Map.of("id", "solution", "label", "솔루션",
"children", List.of(
Map.of("id", "guardia", "label", "GUARDiA ITSM", "path", "/solution/guardia", "badge", "NEW"),
Map.of("id", "erp", "label", "ERP", "path", "/solution/erp"),
Map.of("id", "crm", "label", "CRM", "path", "/solution/crm"),
Map.of("id", "bi", "label", "BI", "path", "/solution/bi")
)),
Map.of("id", "business", "label", "사업실적",
"children", List.of(
Map.of("id", "reference", "label", "구축 레퍼런스", "path", "/business/reference"),
Map.of("id", "partner", "label", "파트너", "path", "/business/partner")
)),
Map.of("id", "support", "label", "고객지원",
"children", List.of(
Map.of("id", "notice", "label", "공지사항", "path", "/support/notice"),
Map.of("id", "faq", "label", "FAQ", "path", "/support/faq"),
Map.of("id", "catalog", "label", "카탈로그", "path", "/support/catalog"),
Map.of("id", "contact", "label", "문의하기", "path", "/support/contact")
)),
Map.of("id", "recruit", "label", "채용",
"children", List.of(
Map.of("id", "jobs", "label", "채용공고", "path", "/recruit/jobs"),
Map.of("id", "welfare", "label", "복리후생", "path", "/recruit/welfare"),
Map.of("id", "apply", "label", "지원하기", "path", "/recruit/apply")
)),
Map.of("id", "news", "label", "뉴스",
"children", List.of(
Map.of("id", "newsroom", "label", "뉴스룸", "path", "/news/newsroom"),
Map.of("id", "blog", "label", "기술 블로그", "path", "/news/blog")
))
));
}
}

32
_archive/backend/src/main/java/kr/co/zioinfo/web/model/AdminUser.java
View File

@ -1,32 +0,0 @@
package kr.co.zioinfo.web.model;
import jakarta.persistence.*;
import lombok.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.time.LocalDateTime;
@Entity @Table(name = "admin_user")
@Getter @Setter @Builder @NoArgsConstructor @AllArgsConstructor
@EntityListeners(AuditingEntityListener.class)
public class AdminUser {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, unique = true, length = 50)
private String username;
@Column(nullable = false)
private String password; // BCrypt encoded
@Column(length = 100)
private String displayName;
@Column(length = 100)
private String email;
private boolean enabled = true;
@CreatedDate
private LocalDateTime createdAt;
}

40
_archive/backend/src/main/java/kr/co/zioinfo/web/model/Inquiry.java
View File

@ -1,40 +0,0 @@
package kr.co.zioinfo.web.model;
import jakarta.persistence.*;
import jakarta.validation.constraints.*;
import lombok.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.time.LocalDateTime;
@Entity @Table(name = "inquiry")
@Getter @Setter @Builder @NoArgsConstructor @AllArgsConstructor
@EntityListeners(AuditingEntityListener.class)
public class Inquiry {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotBlank @Column(nullable = false, length = 50)
private String name;
@NotBlank @Email @Column(nullable = false, length = 100)
private String email;
@Column(length = 30)
private String phone;
@NotBlank @Column(nullable = false, length = 200)
private String subject;
@NotBlank @Column(nullable = false, columnDefinition = "TEXT")
private String content;
@Column(length = 50)
private String category; // 제품문의 | 기술지원 | 사업제안 | 기타
private boolean agreePrivacy = false;
private String status = "PENDING"; // PENDING | ANSWERED
@CreatedDate
private LocalDateTime createdAt;
}

36
_archive/backend/src/main/java/kr/co/zioinfo/web/model/News.java
View File

@ -1,36 +0,0 @@
package kr.co.zioinfo.web.model;
import jakarta.persistence.*;
import lombok.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.time.LocalDateTime;
@Entity @Table(name = "news")
@Getter @Setter @Builder @NoArgsConstructor @AllArgsConstructor
@EntityListeners(AuditingEntityListener.class)
public class News {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 200)
private String title;
@Column(length = 50)
private String category; // 공지사항 | 보도자료 | 이벤트
@Column(columnDefinition = "TEXT")
private String content;
@Column(length = 500)
private String summary;
@Column(length = 300)
private String thumbnailUrl;
private boolean visible = true;
private int viewCount = 0;
@CreatedDate
private LocalDateTime createdAt;
}

41
_archive/backend/src/main/java/kr/co/zioinfo/web/model/Recruit.java
View File

@ -1,41 +0,0 @@
package kr.co.zioinfo.web.model;
import jakarta.persistence.*;
import lombok.*;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import java.time.LocalDate;
import java.time.LocalDateTime;
@Entity @Table(name = "recruit")
@Getter @Setter @Builder @NoArgsConstructor @AllArgsConstructor
@EntityListeners(AuditingEntityListener.class)
public class Recruit {
@Id @GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(nullable = false, length = 200)
private String title;
@Column(length = 50)
private String department; // 개발팀, 영업팀, 기획팀 등
@Column(length = 20)
private String jobType; // 정규직, 계약직, 인턴
@Column(columnDefinition = "TEXT")
private String description; // 담당업무
@Column(columnDefinition = "TEXT")
private String requirements; // 지원자격
@Column(columnDefinition = "TEXT")
private String preferred; // 우대사항
private LocalDate deadline;
private int headcount = 1;
private boolean active = true;
@CreatedDate
private LocalDateTime createdAt;
}

10
_archive/backend/src/main/java/kr/co/zioinfo/web/repository/AdminUserRepository.java
View File

@ -1,10 +0,0 @@
package kr.co.zioinfo.web.repository;
import kr.co.zioinfo.web.model.AdminUser;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.Optional;
public interface AdminUserRepository extends JpaRepository<AdminUser, Long> {
Optional<AdminUser> findByUsername(String username);
boolean existsByUsername(String username);
}

12
_archive/backend/src/main/java/kr/co/zioinfo/web/repository/InquiryRepository.java
View File

@ -1,12 +0,0 @@
package kr.co.zioinfo.web.repository;
import kr.co.zioinfo.web.model.Inquiry;
import org.springframework.data.domain.*;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface InquiryRepository extends JpaRepository<Inquiry, Long> {
Page<Inquiry> findByStatus(String status, Pageable p);
long countByStatus(String status);
List<Inquiry> findTop5ByOrderByCreatedAtDesc();
}

13
_archive/backend/src/main/java/kr/co/zioinfo/web/repository/NewsRepository.java
View File

@ -1,13 +0,0 @@
package kr.co.zioinfo.web.repository;
import kr.co.zioinfo.web.model.News;
import org.springframework.data.domain.*;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface NewsRepository extends JpaRepository<News, Long> {
Page<News> findByVisibleTrue(Pageable p);
Page<News> findByCategoryAndVisibleTrue(String category, Pageable p);
long countByVisibleTrue();
List<News> findTop5ByOrderByCreatedAtDesc();
}

13
_archive/backend/src/main/java/kr/co/zioinfo/web/repository/RecruitRepository.java
View File

@ -1,13 +0,0 @@
package kr.co.zioinfo.web.repository;
import kr.co.zioinfo.web.model.Recruit;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;
public interface RecruitRepository extends JpaRepository<Recruit, Long> {
List<Recruit> findByActiveTrueOrderByCreatedAtDesc();
Page<Recruit> findAllByOrderByCreatedAtDesc(Pageable pageable);
long countByActiveTrue();
}

35
_archive/backend/src/main/java/kr/co/zioinfo/web/security/JwtAuthFilter.java
View File

@ -1,35 +0,0 @@
package kr.co.zioinfo.web.security;
import jakarta.servlet.*;
import jakarta.servlet.http.*;
import lombok.RequiredArgsConstructor;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;
import java.io.IOException;
import java.util.List;
@Component
@RequiredArgsConstructor
public class JwtAuthFilter extends OncePerRequestFilter {
private final JwtUtil jwtUtil;
@Override
protected void doFilterInternal(HttpServletRequest req, HttpServletResponse res, FilterChain chain)
throws ServletException, IOException {
String header = req.getHeader("Authorization");
if (header != null && header.startsWith("Bearer ")) {
String token = header.substring(7);
if (jwtUtil.isValid(token)) {
String username = jwtUtil.extractUsername(token);
var auth = new UsernamePasswordAuthenticationToken(
username, null, List.of(new SimpleGrantedAuthority("ROLE_ADMIN")));
SecurityContextHolder.getContext().setAuthentication(auth);
}
}
chain.doFilter(req, res);
}
}

49
_archive/backend/src/main/java/kr/co/zioinfo/web/security/JwtUtil.java
View File

@ -1,49 +0,0 @@
package kr.co.zioinfo.web.security;
import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import javax.crypto.SecretKey;
import java.nio.charset.StandardCharsets;
import java.util.Date;
@Component
public class JwtUtil {
private final SecretKey key;
private final long expirationMs;
public JwtUtil(
@Value("${zioinfo.jwt.secret:zioinfo-admin-secret-key-must-be-at-least-32-chars}") String secret,
@Value("${zioinfo.jwt.expiration-ms:28800000}") long expirationMs) {
this.key = Keys.hmacShaKeyFor(secret.getBytes(StandardCharsets.UTF_8));
this.expirationMs = expirationMs;
}
public String generate(String username) {
return Jwts.builder()
.subject(username)
.issuedAt(new Date())
.expiration(new Date(System.currentTimeMillis() + expirationMs))
.signWith(key)
.compact();
}
public String extractUsername(String token) {
return parse(token).getPayload().getSubject();
}
public boolean isValid(String token) {
try {
parse(token);
return true;
} catch (JwtException | IllegalArgumentException e) {
return false;
}
}
private Jws<Claims> parse(String token) {
return Jwts.parser().verifyWith(key).build().parseSignedClaims(token);
}
}

Some files were not shown because too many files have changed in this diff Show More