From fd5a68e44ac484d9e80225aac2370316c314504c Mon Sep 17 00:00:00 2001
From: Hyungi Ahn <hyungiahn@Hyungiui-MacBookPro.local>
Date: Tue, 25 Nov 2025 10:39:58 +0900
Subject: [PATCH] =?UTF-8?q?=F0=9F=8E=AF=20=ED=94=84=EB=A1=9C=EC=A0=9D?=
 =?UTF-8?q?=ED=8A=B8=20=EB=A6=AC=EB=B8=8C=EB=9E=9C=EB=94=A9:=20Kumamoto=20?=
 =?UTF-8?q?=E2=86=92=20Travel=20Planner=20v2.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

✨ 주요 변경사항:
- 프로젝트 이름: kumamoto-travel-planner → travel-planner
- 버전 업그레이드: v1.0.0 → v2.0.0
- 멀티유저 시스템 구현 (JWT 인증)
- PostgreSQL 마이그레이션 시스템 추가
- Docker 컨테이너 이름 변경
- UI 브랜딩 업데이트 (Travel Planner)
- API 서버 및 인증 시스템 추가
- 여행 공유 기능 구현
- 템플릿 시스템 추가

🔧 기술 스택:
- Frontend: React + TypeScript + Vite
- Backend: Node.js + Express + JWT
- Database: PostgreSQL + 마이그레이션
- Infrastructure: Docker + Docker Compose

🌟 새로운 기능:
- 사용자 인증 및 권한 관리
- 다중 여행 계획 관리
- 여행 템플릿 시스템
- 공유 링크 및 댓글 시스템
- 관리자 대시보드
---
 DATABASE_SETUP.md                             |  213 ++
 IMPROVEMENT_PLAN.md                           |  125 +
 README.md                                     |  199 +-
 docker-compose.dev.yml                        |   64 +-
 docker-compose.yml                            |   34 +-
 docker-start.sh                               |   66 +
 env.docker                                    |    4 +
 index.html                                    |    2 +-
 package-lock.json                             |   56 +-
 package.json                                  |    7 +-
 server/Dockerfile                             |   27 +
 server/db.js                                  |   45 +
 server/env.example                            |   18 +
 server/migrate.js                             |   80 +
 server/migrations/001_add_user_system.sql     |  129 +
 server/package-lock.json                      | 2154 +++++++++++++++++
 server/package.json                           |   22 +
 server/routes/auth.js                         |  179 ++
 server/routes/basePoints.js                   |   77 +
 server/routes/setup.js                        |  187 ++
 server/routes/travelPlans.js                  |  183 ++
 server/routes/uploads.js                      |   88 +
 server/schema.sql                             |   66 +
 server/schema_v2.sql                          |  226 ++
 server/server.js                              |   66 +
 .../images-1762666367693-99912431.webp        |  Bin 0 -> 31956 bytes
 .../images-1762666492636-867051147.jpg        |  Bin 0 -> 63403 bytes
 src/App.tsx                                   |  378 +--
 src/components/ActivityEditor.tsx             |  208 ++
 src/components/AdminDashboard.tsx             |  510 ++++
 src/components/Attractions.tsx                |   95 +-
 src/components/AuthForm.tsx                   |  298 +++
 src/components/DebugInfo.tsx                  |  164 ++
 src/components/DynamicMap.tsx                 |   80 +
 src/components/GoogleAuthManager.tsx          |  285 +++
 src/components/GoogleMapComponent.tsx         |  497 ++++
 src/components/GoogleMapsApiKeyManager.tsx    |  245 ++
 src/components/GoogleMapsUsageIndicator.tsx   |  179 ++
 src/components/Header.tsx                     |    4 +-
 src/components/InitialSetup.tsx               |  429 ++++
 src/components/LeafletMapComponent.tsx        |  561 +++++
 src/components/Map.tsx                        |    4 +-
 src/components/MobileTabBar.tsx               |   47 +
 src/components/PlacesSearch.tsx               |  272 +++
 src/components/RelatedPlacesManager.tsx       |  472 ++++
 src/components/RouteOptimizer.tsx             |  239 ++
 src/components/SharedTripViewer.tsx           |  428 ++++
 src/components/TabNavigation.tsx              |   55 +
 src/components/TemplateBrowser.tsx            |  485 ++++
 src/components/Timeline.tsx                   |  541 +++--
 src/components/TravelDashboard.tsx            |  136 ++
 src/components/TravelMap.tsx                  |  535 ++++
 src/components/TripSharingManager.tsx         |  436 ++++
 src/components/UnifiedMap.tsx                 |  303 +++
 src/components/UserDashboard.tsx              |  660 +++++
 src/components/forms/CoordinateInput.tsx      |   58 +
 src/components/forms/ImageUploadField.tsx     |  103 +
 src/components/forms/LinkManagement.tsx       |  177 ++
 src/components/forms/LocationSelector.tsx     |  139 ++
 src/constants/defaultData.ts                  |  232 ++
 src/data/tripTemplates.ts                     |  590 +++++
 src/env.d.ts                                  |   12 +
 src/index.css                                 |   11 +
 src/pages/PlanPage.tsx                        |  278 +++
 src/pages/TripPage.tsx                        |  332 +++
 src/services/api.ts                           |   98 +
 src/services/apiKeyManager.ts                 |  171 ++
 src/services/googleAuth.ts                    |  319 +++
 src/services/googleDirections.ts              |  313 +++
 src/services/googleMapsUsage.ts               |  257 ++
 src/services/googlePlaces.ts                  |  267 ++
 src/services/initialSetup.ts                  |  304 +++
 src/services/offlineSupport.ts                |  381 +++
 src/services/tripManager.ts                   |  517 ++++
 src/services/tripSharing.ts                   |  395 +++
 src/services/userAuth.ts                      |  673 +++++
 src/types.ts                                  |  123 +-
 src/utils/categoryMapping.ts                  |  129 +
 src/utils/env.ts                              |   34 +
 start-server.sh                               |   40 +
 tailwind.config.js                            |    3 +
 81 files changed, 18420 insertions(+), 399 deletions(-)
 create mode 100644 DATABASE_SETUP.md
 create mode 100644 IMPROVEMENT_PLAN.md
 create mode 100644 docker-start.sh
 create mode 100644 env.docker
 create mode 100644 server/Dockerfile
 create mode 100644 server/db.js
 create mode 100644 server/env.example
 create mode 100644 server/migrate.js
 create mode 100644 server/migrations/001_add_user_system.sql
 create mode 100644 server/package-lock.json
 create mode 100644 server/package.json
 create mode 100644 server/routes/auth.js
 create mode 100644 server/routes/basePoints.js
 create mode 100644 server/routes/setup.js
 create mode 100644 server/routes/travelPlans.js
 create mode 100644 server/routes/uploads.js
 create mode 100644 server/schema.sql
 create mode 100644 server/schema_v2.sql
 create mode 100644 server/server.js
 create mode 100644 server/uploads/images-1762666367693-99912431.webp
 create mode 100644 server/uploads/images-1762666492636-867051147.jpg
 create mode 100644 src/components/ActivityEditor.tsx
 create mode 100644 src/components/AdminDashboard.tsx
 create mode 100644 src/components/AuthForm.tsx
 create mode 100644 src/components/DebugInfo.tsx
 create mode 100644 src/components/DynamicMap.tsx
 create mode 100644 src/components/GoogleAuthManager.tsx
 create mode 100644 src/components/GoogleMapComponent.tsx
 create mode 100644 src/components/GoogleMapsApiKeyManager.tsx
 create mode 100644 src/components/GoogleMapsUsageIndicator.tsx
 create mode 100644 src/components/InitialSetup.tsx
 create mode 100644 src/components/LeafletMapComponent.tsx
 create mode 100644 src/components/MobileTabBar.tsx
 create mode 100644 src/components/PlacesSearch.tsx
 create mode 100644 src/components/RelatedPlacesManager.tsx
 create mode 100644 src/components/RouteOptimizer.tsx
 create mode 100644 src/components/SharedTripViewer.tsx
 create mode 100644 src/components/TabNavigation.tsx
 create mode 100644 src/components/TemplateBrowser.tsx
 create mode 100644 src/components/TravelDashboard.tsx
 create mode 100644 src/components/TravelMap.tsx
 create mode 100644 src/components/TripSharingManager.tsx
 create mode 100644 src/components/UnifiedMap.tsx
 create mode 100644 src/components/UserDashboard.tsx
 create mode 100644 src/components/forms/CoordinateInput.tsx
 create mode 100644 src/components/forms/ImageUploadField.tsx
 create mode 100644 src/components/forms/LinkManagement.tsx
 create mode 100644 src/components/forms/LocationSelector.tsx
 create mode 100644 src/constants/defaultData.ts
 create mode 100644 src/data/tripTemplates.ts
 create mode 100644 src/env.d.ts
 create mode 100644 src/pages/PlanPage.tsx
 create mode 100644 src/pages/TripPage.tsx
 create mode 100644 src/services/api.ts
 create mode 100644 src/services/apiKeyManager.ts
 create mode 100644 src/services/googleAuth.ts
 create mode 100644 src/services/googleDirections.ts
 create mode 100644 src/services/googleMapsUsage.ts
 create mode 100644 src/services/googlePlaces.ts
 create mode 100644 src/services/initialSetup.ts
 create mode 100644 src/services/offlineSupport.ts
 create mode 100644 src/services/tripManager.ts
 create mode 100644 src/services/tripSharing.ts
 create mode 100644 src/services/userAuth.ts
 create mode 100644 src/utils/categoryMapping.ts
 create mode 100644 src/utils/env.ts
 create mode 100644 start-server.sh

diff --git a/DATABASE_SETUP.md b/DATABASE_SETUP.md
new file mode 100644
index 0000000..7523708
--- /dev/null
+++ b/DATABASE_SETUP.md
@@ -0,0 +1,213 @@
+# 🗄️ 데이터베이스 설정 가이드
+
+## 📋 개요
+Travel Planner v2.0은 PostgreSQL을 사용하여 멀티 사용자 여행 계획을 관리합니다.
+
+## 🚀 빠른 시작
+
+### 1. PostgreSQL 설치 확인
+```bash
+# PostgreSQL 버전 확인
+psql --version
+
+# PostgreSQL 서비스 상태 확인 (macOS)
+brew services list | grep postgresql
+
+# PostgreSQL 시작 (macOS)
+brew services start postgresql
+```
+
+### 2. 데이터베이스 생성
+```bash
+# PostgreSQL 접속
+psql postgres
+
+# 데이터베이스 생성
+CREATE DATABASE kumamoto_travel;
+
+# 사용자 생성 (선택사항)
+CREATE USER kumamoto_user WITH PASSWORD 'your_password';
+GRANT ALL PRIVILEGES ON DATABASE kumamoto_travel TO kumamoto_user;
+
+# 종료
+\q
+```
+
+### 3. 환경 변수 설정
+```bash
+# 서버 디렉토리로 이동
+cd server
+
+# 환경 변수 파일 생성
+cp env.example .env
+
+# .env 파일 편집
+nano .env
+```
+
+### 4. .env 파일 예시
+```env
+# 기본 설정 (로컬 개발용)
+DATABASE_URL=postgresql://localhost:5432/kumamoto_travel
+
+# 사용자 계정을 만든 경우
+DATABASE_URL=postgresql://kumamoto_user:your_password@localhost:5432/kumamoto_travel
+
+# JWT 시크릿 (랜덤한 문자열로 변경하세요)
+JWT_SECRET=your-super-secret-jwt-key-change-this-in-production-123456789
+
+# 선택사항
+GOOGLE_MAPS_API_KEY=your-google-maps-api-key
+PORT=3000
+NODE_ENV=development
+```
+
+## 🔧 서버 시작
+
+### 1. 의존성 설치
+```bash
+cd server
+npm install
+```
+
+### 2. 서버 실행
+```bash
+# 개발 모드
+npm run dev
+
+# 또는 일반 모드
+npm start
+```
+
+### 3. 서버 확인
+```bash
+# 헬스 체크
+curl http://localhost:3000/health
+
+# 데이터베이스 연결 테스트
+curl http://localhost:3000/api/setup/test-db
+
+# 설정 상태 확인
+curl http://localhost:3000/api/setup/status
+```
+
+## 📊 데이터베이스 스키마
+
+### 주요 테이블
+- **users**: 사용자 계정 (관리자/일반 사용자)
+- **travel_plans**: 여행 계획 (멀티 목적지 지원)
+- **day_schedules**: 날짜별 일정
+- **activities**: 개별 활동
+- **share_links**: 공유 링크 관리
+- **trip_comments**: 여행 계획 댓글
+
+### 스키마 업데이트
+```bash
+# 기존 데이터가 있는 경우 백업
+pg_dump kumamoto_travel > backup.sql
+
+# 새 스키마 적용
+psql kumamoto_travel < server/schema_v2.sql
+```
+
+## 🔐 보안 설정
+
+### JWT 시크릿 생성
+```bash
+# 랜덤 시크릿 생성 (Node.js)
+node -e "console.log(require('crypto').randomBytes(64).toString('hex'))"
+
+# 또는 OpenSSL 사용
+openssl rand -hex 64
+```
+
+### 데이터베이스 보안
+```sql
+-- 사용자별 권한 설정
+REVOKE ALL ON SCHEMA public FROM PUBLIC;
+GRANT USAGE ON SCHEMA public TO kumamoto_user;
+GRANT ALL ON ALL TABLES IN SCHEMA public TO kumamoto_user;
+GRANT ALL ON ALL SEQUENCES IN SCHEMA public TO kumamoto_user;
+```
+
+## 🐛 문제 해결
+
+### 연결 오류
+```bash
+# PostgreSQL 실행 확인
+ps aux | grep postgres
+
+# 포트 확인
+lsof -i :5432
+
+# 로그 확인
+tail -f /usr/local/var/log/postgres.log
+```
+
+### 권한 오류
+```sql
+-- 데이터베이스 소유자 변경
+ALTER DATABASE kumamoto_travel OWNER TO kumamoto_user;
+
+-- 테이블 권한 부여
+GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO kumamoto_user;
+```
+
+### 스키마 초기화
+```bash
+# 모든 테이블 삭제 후 재생성
+psql kumamoto_travel -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;"
+psql kumamoto_travel < server/schema_v2.sql
+```
+
+## 📈 성능 최적화
+
+### 인덱스 확인
+```sql
+-- 인덱스 사용 현황
+SELECT schemaname, tablename, indexname, idx_tup_read, idx_tup_fetch 
+FROM pg_stat_user_indexes;
+
+-- 느린 쿼리 확인
+SELECT query, mean_time, calls FROM pg_stat_statements ORDER BY mean_time DESC;
+```
+
+### 연결 풀 설정
+```javascript
+// server/db.js에서 연결 풀 조정
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: 20,          // 최대 연결 수
+  idleTimeoutMillis: 30000,
+  connectionTimeoutMillis: 2000,
+});
+```
+
+## 🚀 프로덕션 배포
+
+### 환경 변수 (프로덕션)
+```env
+DATABASE_URL=postgresql://user:password@host:port/database?sslmode=require
+JWT_SECRET=production-secret-key-very-long-and-random
+NODE_ENV=production
+PORT=3000
+```
+
+### SSL 설정
+```javascript
+// SSL 연결 (프로덕션)
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+});
+```
+
+## 📞 지원
+
+문제가 발생하면 다음을 확인하세요:
+1. PostgreSQL 서비스 실행 상태
+2. .env 파일의 DATABASE_URL 정확성
+3. 데이터베이스 사용자 권한
+4. 방화벽 설정 (포트 5432, 3000)
+
+성공적으로 설정되면 브라우저에서 `http://localhost:5173`에 접속하여 초기 설정을 완료할 수 있습니다.
diff --git a/IMPROVEMENT_PLAN.md b/IMPROVEMENT_PLAN.md
new file mode 100644
index 0000000..07d4a83
--- /dev/null
+++ b/IMPROVEMENT_PLAN.md
@@ -0,0 +1,125 @@
+# 구마모토 여행 앱 UI 개선 계획
+
+## 📋 개선 목표
+
+### 데스크톱 모드 (계획 수립 중심)
+**목표**: 효율적인 여행 계획 수립을 위한 종합 대시보드
+
+### 모바일 모드 (여행 중 사용)
+**목표**: 여행 중 필요한 정보에 빠르게 접근할 수 있는 실용적 인터페이스
+
+---
+
+## 🖥️ 데스크톱 모드 개선 계획
+
+### 1. 레이아웃 최적화
+- **3컬럼 레이아웃**: 지도(50%) | 일정(30%) | 정보(20%)
+- **상단 대시보드**: 여행 개요, 진행률, 예산 요약
+- **탭 기반 네비게이션**: 일정 | 관광지 | 예산 | 체크리스트
+
+### 2. 일정 편집 기능 강화
+- **드래그앤드롭**: 일정 순서 변경
+- **시간 슬라이더**: 직관적 시간 조정
+- **관광지 연동**: 관광지 목록에서 일정으로 드래그
+- **자동 시간 계산**: 이동 시간 자동 계산
+
+### 3. 정보 통합 및 시각화
+- **진행률 표시**: 계획 완성도 시각화
+- **예산 차트**: 카테고리별 예산 분배
+- **날씨 정보**: 여행 날짜 날씨 예보
+- **교통 정보**: 경로 및 소요 시간
+
+### 4. 협업 기능
+- **공유 링크**: 가족과 계획 공유
+- **댓글 시스템**: 일정별 메모/의견
+- **버전 관리**: 계획 변경 이력
+
+---
+
+## 📱 모바일 모드 개선 계획
+
+### 1. 네비게이션 최적화
+- **하단 탭바**: 지도 | 오늘일정 | 전체일정 | 더보기
+- **플로팅 액션 버튼**: 현재위치, 다음장소, 긴급연락
+- **스와이프 제스처**: 날짜 간 빠른 전환
+
+### 2. 실시간 여행 지원
+- **현재 진행 상황**: 완료된 일정 체크
+- **다음 목적지**: 현재 위치에서 다음 장소까지 길찾기
+- **실시간 알림**: 일정 시간 알림, 교통 정보
+- **오프라인 모드**: 필수 정보 캐싱
+
+### 3. 빠른 액세스 기능
+- **원터치 액션**: 전화걸기, 길찾기, 메모
+- **음성 메모**: 여행 중 간편 기록
+- **사진 연동**: 장소별 사진 자동 분류
+- **체크인 기능**: 방문 완료 체크
+
+### 4. 여행 중 편의 기능
+- **언어 지원**: 일본어 기본 문구
+- **환율 계산기**: 실시간 환율 적용
+- **긴급 정보**: 병원, 경찰서, 대사관
+- **교통카드 잔액**: IC카드 사용 기록
+
+---
+
+## 🔄 공통 개선 사항
+
+### 1. 성능 최적화
+- **로딩 시간 단축**: 이미지 최적화, 코드 스플리팅
+- **오프라인 지원**: PWA 적용, 캐싱 전략
+- **배터리 최적화**: 위치 서비스 효율화
+
+### 2. 접근성 개선
+- **다국어 지원**: 한국어, 일본어, 영어
+- **다크모드**: 야간 사용 편의성
+- **폰트 크기 조절**: 사용자 맞춤 설정
+
+### 3. 데이터 동기화
+- **실시간 동기화**: 데스크톱-모바일 간 즉시 반영
+- **오프라인 동기화**: 연결 복구 시 자동 동기화
+- **백업/복원**: 클라우드 백업 기능
+
+---
+
+## 📅 구현 우선순위
+
+### Phase 1: 핵심 기능 개선 (1주)
+1. 데스크톱 3컬럼 레이아웃 구현
+2. 모바일 하단 탭바 네비게이션
+3. 일정 드래그앤드롭 기능
+4. 진행 상황 표시
+
+### Phase 2: 사용성 향상 (1주)
+1. 관광지-일정 연동 기능
+2. 실시간 위치 기반 기능
+3. 오프라인 모드 기본 구현
+4. 성능 최적화
+
+### Phase 3: 고급 기능 (1주)
+1. 협업 및 공유 기능
+2. 음성/사진 연동
+3. 다국어 지원
+4. PWA 완성
+
+---
+
+## 🎨 디자인 시스템
+
+### 색상 팔레트
+- **Primary**: 구마모토 레드 (#DC2626)
+- **Secondary**: 구마모토 그린 (#059669)
+- **Accent**: 구마모토 블루 (#2563EB)
+- **Neutral**: 회색 계열 (#F3F4F6 ~ #1F2937)
+
+### 타이포그래피
+- **제목**: Inter/Noto Sans KR Bold
+- **본문**: Inter/Noto Sans KR Regular
+- **캡션**: Inter/Noto Sans KR Medium
+
+### 컴포넌트 일관성
+- **버튼**: 둥근 모서리, 그림자 효과
+- **카드**: 미니멀 디자인, 호버 효과
+- **입력**: 명확한 라벨, 에러 상태
+- **아이콘**: 일관된 스타일, 의미 명확
+
diff --git a/README.md b/README.md
index a4bdf72..c452ecb 100644
--- a/README.md
+++ b/README.md
@@ -1,54 +1,195 @@
-# 구마모토 여행 계획 사이트
+# ✈️ Travel Planner
 
-2025년 2월 17일 ~ 2월 20일 구마모토 여행을 위한 가족 공유 여행 계획 사이트입니다.
+**스마트한 여행 계획 관리 시스템**
 
-## 기능
+다중 사용자를 지원하는 현대적인 여행 계획 웹 애플리케이션입니다. 여행 일정 관리, 지도 통합, 공유 기능을 제공합니다.
 
-- 📅 **여행 일정 관리**: 날짜별 일정을 추가하고 관리할 수 있습니다
-- 🗾 **관광지 정보**: 구마모토 주요 관광지 정보를 확인할 수 있습니다
-- 💰 **예산 관리**: 항목별 예산을 설정하고 환율을 적용해 원화로 확인할 수 있습니다
-- ✅ **체크리스트**: 준비물, 쇼핑 목록, 방문할 곳 등을 체크리스트로 관리합니다
+## 🌟 주요 기능
 
-## 시작하기
+### 👥 멀티 사용자 시스템
+- **사용자 인증**: JWT 기반 로그인/회원가입
+- **관리자 시스템**: 사용자 및 시스템 관리
+- **권한 관리**: 개인/공개 여행 계획 설정
 
-### 설치
+### 🗺️ 여행 계획 관리
+- **다중 여행 관리**: 여러 여행 계획 동시 관리
+- **템플릿 시스템**: 도시별 여행 템플릿 제공
+- **일정 관리**: 날짜별 상세 일정 작성
+- **장소 검색**: Google Places API 통합
+
+### 🔗 공유 및 협업
+- **여행 공유**: 링크를 통한 여행 계획 공유
+- **권한 설정**: 보기/편집/댓글 권한 제어
+- **댓글 시스템**: 공유된 여행에 댓글 작성
+
+### 🗺️ 지도 통합
+- **Google Maps**: 장소 검색 및 경로 최적화
+- **Leaflet**: 오프라인 지도 지원
+- **경로 계획**: 여행지 간 최적 경로 제안
+
+## 🚀 빠른 시작
+
+### Docker로 실행 (권장)
 
 ```bash
-npm install
+# 저장소 클론
+git clone <repository-url>
+cd travel-planner
+
+# Docker 환경 시작
+./docker-start.sh
+
+# 또는 수동 실행
+docker-compose up -d
 ```
 
-### 개발 서버 실행
+### 로컬 개발 환경
 
 ```bash
+# 의존성 설치
+npm install
+
+# 개발 서버 시작
+npm run dev
+
+# API 서버 시작 (별도 터미널)
+cd server
+npm install
 npm run dev
 ```
 
-브라우저에서 `http://localhost:5173`을 열어 확인하세요.
+## 🔧 환경 설정
 
-### 빌드
+### 필수 환경 변수
 
-```bash
-npm run build
+```env
+# 프론트엔드 (.env)
+VITE_API_URL=http://localhost:3001
+VITE_GOOGLE_OAUTH_CLIENT_ID=your-google-oauth-client-id
+
+# 백엔드 (server/.env)
+DATABASE_URL=postgresql://user:password@localhost:5432/travel_planner
+JWT_SECRET=your-jwt-secret-key
+GOOGLE_MAPS_API_KEY=your-google-maps-api-key
 ```
 
-## 기술 스택
+### 데이터베이스 설정
 
-- React 18
-- TypeScript
-- Vite
-- Tailwind CSS
-- date-fns
+```bash
+# PostgreSQL 설치 및 시작
+brew install postgresql
+brew services start postgresql
 
-## 사용 방법
+# 데이터베이스 생성
+createdb travel_planner
 
-1. **일정 추가**: 각 날짜 옆의 "+ 일정 추가" 버튼을 클릭하여 일정을 추가합니다
-2. **예산 설정**: 예산 관리 섹션에서 각 항목을 클릭하여 예산을 입력합니다
-3. **체크리스트**: 체크리스트에 항목을 추가하고 완료 시 체크박스를 클릭합니다
+# 마이그레이션 실행 (자동)
+npm start  # 서버 시작 시 자동 실행
+```
 
-## 공유하기
+## 📁 프로젝트 구조
 
-이 사이트는 로컬 스토리지를 사용하여 데이터를 저장합니다. 가족과 공유하려면:
+```
+travel-planner/
+├── src/                    # 프론트엔드 소스
+│   ├── components/         # React 컴포넌트
+│   ├── services/          # API 서비스
+│   ├── types/             # TypeScript 타입
+│   └── utils/             # 유틸리티 함수
+├── server/                # 백엔드 API
+│   ├── routes/            # API 라우트
+│   ├── migrations/        # DB 마이그레이션
+│   └── uploads/           # 파일 업로드
+├── docker/                # Docker 설정
+└── docs/                  # 문서
+```
 
-1. 개발 서버를 실행한 후 네트워크 IP로 접근하거나
-2. 빌드 후 정적 호스팅 서비스(Vercel, Netlify 등)에 배포하세요
+## 🛠️ 기술 스택
 
+### 프론트엔드
+- **React 18** + **TypeScript**
+- **Vite** (빌드 도구)
+- **Tailwind CSS** (스타일링)
+- **React Router** (라우팅)
+- **Leaflet** + **Google Maps** (지도)
+
+### 백엔드
+- **Node.js** + **Express**
+- **PostgreSQL** (데이터베이스)
+- **JWT** (인증)
+- **Multer** (파일 업로드)
+
+### 인프라
+- **Docker** + **Docker Compose**
+- **Nginx** (프로덕션)
+
+## 📊 API 문서
+
+### 인증 API
+```
+POST /api/auth/register     # 회원가입
+POST /api/auth/login        # 로그인  
+GET  /api/auth/verify       # 토큰 검증
+```
+
+### 여행 계획 API
+```
+GET    /api/travel-plans           # 여행 목록
+POST   /api/travel-plans           # 여행 생성
+GET    /api/travel-plans/:id       # 여행 조회
+PUT    /api/travel-plans/:id       # 여행 수정
+DELETE /api/travel-plans/:id       # 여행 삭제
+```
+
+### 공유 API
+```
+POST /api/share/create      # 공유 링크 생성
+GET  /api/share/:code       # 공유된 여행 조회
+```
+
+## 🔒 보안
+
+- **JWT 토큰**: 안전한 사용자 인증
+- **비밀번호 해시**: bcrypt 암호화
+- **SQL 인젝션 방지**: 매개변수화된 쿼리
+- **CORS 설정**: 허용된 도메인만 접근
+
+## 🌍 배포
+
+### Docker 배포
+```bash
+# 프로덕션 빌드
+docker-compose -f docker-compose.prod.yml up -d
+```
+
+### 수동 배포
+```bash
+# 프론트엔드 빌드
+npm run build
+
+# 서버 시작
+cd server
+npm start
+```
+
+## 🤝 기여하기
+
+1. Fork the repository
+2. Create feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit changes (`git commit -m 'Add amazing feature'`)
+4. Push to branch (`git push origin feature/amazing-feature`)
+5. Open Pull Request
+
+## 📝 라이선스
+
+MIT License - 자세한 내용은 [LICENSE](LICENSE) 파일을 참조하세요.
+
+## 📞 지원
+
+- **이슈 리포트**: GitHub Issues
+- **문서**: [Wiki](../../wiki)
+- **FAQ**: [자주 묻는 질문](docs/FAQ.md)
+
+---
+
+**Travel Planner** - 당신의 완벽한 여행을 계획하세요! ✈️🗺️
\ No newline at end of file
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index d1ed09f..a3097cf 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,6 +1,40 @@
-version: '3.8'
-
 services:
+  # PostgreSQL Database
+  db:
+    image: postgres:16-alpine
+    container_name: kumamoto-db
+    environment:
+      POSTGRES_USER: kumamoto
+      POSTGRES_PASSWORD: kumamoto123
+      POSTGRES_DB: kumamoto_travel
+      TZ: Asia/Seoul
+      PGTZ: Asia/Seoul
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    restart: unless-stopped
+
+  # Backend API Server
+  api:
+    image: node:20-alpine
+    container_name: kumamoto-api
+    working_dir: /app
+    volumes:
+      - ./server:/app
+      - /app/node_modules
+    ports:
+      - "3000:3000"
+    environment:
+      DATABASE_URL: postgresql://kumamoto:kumamoto123@db:5432/kumamoto_travel
+      NODE_ENV: development
+      TZ: Asia/Seoul
+    command: sh -c "npm install && npm run dev"
+    depends_on:
+      - db
+    restart: unless-stopped
+
+  # Frontend (Vite)
   web:
     image: node:20-alpine
     working_dir: /app
@@ -9,31 +43,15 @@ services:
       - /app/node_modules
     ports:
       - "5173:5173"
+    environment:
+      VITE_API_URL: http://localhost:3000
+      TZ: Asia/Seoul
     command: sh -c "npm install && npm run dev -- --host"
     container_name: kumamoto-travel-planner-dev
-    restart: unless-stopped
     depends_on:
-      - map-server
-    environment:
-      - VITE_MAP_TILES_URL=http://localhost:8080/tiles
-
-  map-server:
-    build:
-      context: ./docker/map-server
-      dockerfile: Dockerfile
-    ports:
-      - "8080:80"
-    container_name: kumamoto-map-server-dev
+      - api
     restart: unless-stopped
-    volumes:
-      - map_data_dev:/var/lib/postgresql/data
-      - map_tiles_dev:/var/www/html/tiles
-    environment:
-      - POSTGRES_DB=kumamoto_map
-      - POSTGRES_USER=postgres
-      - POSTGRES_PASSWORD=mapserver123
 
 volumes:
-  map_data_dev:
-  map_tiles_dev:
+  postgres_data:
 
diff --git a/docker-compose.yml b/docker-compose.yml
index 012c62a..fd41e7e 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,26 +1,50 @@
 version: '3.8'
 
 services:
+  # 프론트엔드
   web:
     build:
       context: .
       dockerfile: Dockerfile
     ports:
       - "3000:80"
-    container_name: kumamoto-travel-planner
+    container_name: travel-planner-web
+    restart: unless-stopped
+    depends_on:
+      - api-server
+      - map-server
+    environment:
+      - VITE_MAP_TILES_URL=http://localhost:8080/tiles
+      - VITE_API_URL=http://localhost:3001
+
+  # API 서버
+  api-server:
+    build:
+      context: ./server
+      dockerfile: Dockerfile
+    ports:
+      - "3001:3000"
+    container_name: travel-planner-api
     restart: unless-stopped
     depends_on:
       - map-server
     environment:
-      - VITE_MAP_TILES_URL=http://localhost:8080/tiles
+      - DATABASE_URL=postgresql://postgres:mapserver123@map-server:5432/kumamoto_map
+      - JWT_SECRET=travel-planner-jwt-secret-key-2024-docker
+      - NODE_ENV=production
+      - PORT=3000
+    volumes:
+      - ./server/uploads:/app/uploads
+      - ./server/migrations:/app/migrations
 
+  # 지도 서버 (기존)
   map-server:
     build:
       context: ./docker/map-server
       dockerfile: Dockerfile
     ports:
       - "8080:80"
-    container_name: kumamoto-map-server
+    container_name: travel-planner-map-server
     restart: unless-stopped
     volumes:
       - map_data:/var/lib/postgresql/data
@@ -31,6 +55,6 @@ services:
       - POSTGRES_PASSWORD=mapserver123
 
 volumes:
-  map_data:
-  map_tiles:
+  map_data:    # 지도 데이터 (기존 DB 포함)
+  map_tiles:   # 지도 타일
 
diff --git a/docker-start.sh b/docker-start.sh
new file mode 100644
index 0000000..cbe02a2
--- /dev/null
+++ b/docker-start.sh
@@ -0,0 +1,66 @@
+#!/bin/bash
+
+# Travel Planner Docker 시작 스크립트
+
+echo "🐳 Travel Planner Docker 환경 시작 중..."
+
+# 기존 컨테이너 정리 (선택사항)
+read -p "기존 컨테이너를 정리하시겠습니까? (y/N): " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    echo "🧹 기존 컨테이너 정리 중..."
+    docker-compose down -v
+    docker system prune -f
+fi
+
+# 환경 변수 파일 확인
+if [ ! -f .env ]; then
+    echo "📋 환경 변수 파일 생성 중..."
+    cp env.docker .env
+    echo "⚠️  .env 파일을 확인하고 필요한 설정을 수정하세요."
+fi
+
+# 서버 환경 변수 확인
+if [ ! -f server/.env ]; then
+    echo "📋 서버 환경 변수 파일 생성 중..."
+    cp server/env.example server/.env
+    echo "✅ 서버 환경 변수가 Docker Compose에서 자동 설정됩니다."
+fi
+
+# Docker 이미지 빌드 및 시작
+echo "🔨 Docker 이미지 빌드 중..."
+docker-compose build
+
+echo "🚀 서비스 시작 중..."
+docker-compose up -d
+
+# 서비스 상태 확인
+echo "⏳ 서비스 시작 대기 중..."
+sleep 10
+
+echo "🔍 서비스 상태 확인 중..."
+docker-compose ps
+
+# 헬스 체크
+echo "🏥 헬스 체크 중..."
+echo "- 프론트엔드: http://localhost:3000"
+echo "- API 서버: http://localhost:3001/health"
+echo "- 지도 서버: http://localhost:8080"
+echo "- 데이터베이스: localhost:5432"
+
+# API 서버 헬스 체크
+echo ""
+echo "📡 API 서버 연결 테스트..."
+sleep 5
+curl -f http://localhost:3001/health || echo "⚠️  API 서버가 아직 시작 중입니다. 잠시 후 다시 시도하세요."
+
+echo ""
+echo "🎉 Travel Planner Docker 환경이 시작되었습니다!"
+echo ""
+echo "📖 사용법:"
+echo "  - 웹 애플리케이션: http://localhost:3000"
+echo "  - 초기 설정: http://localhost:3000/?debug=true"
+echo "  - API 서버: http://localhost:3001"
+echo "  - 로그 확인: docker-compose logs -f"
+echo "  - 중지: docker-compose down"
+echo ""
diff --git a/env.docker b/env.docker
new file mode 100644
index 0000000..c5bf22d
--- /dev/null
+++ b/env.docker
@@ -0,0 +1,4 @@
+# Docker 환경 변수 (기존 DB 사용)
+VITE_API_URL=http://localhost:3001
+VITE_MAP_TILES_URL=http://localhost:8080/tiles
+VITE_GOOGLE_OAUTH_CLIENT_ID=your-google-oauth-client-id
diff --git a/index.html b/index.html
index 3ab28ee..cd9499b 100644
--- a/index.html
+++ b/index.html
@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>구마모토 여행 계획 - 2025년 2월</title>
+    <title>Travel Planner - 여행 계획 관리 시스템</title>
   </head>
   <body>
     <div id="root"></div>
diff --git a/package-lock.json b/package-lock.json
index 02d3572..44af81a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -13,7 +13,8 @@
         "leaflet": "^1.9.4",
         "react": "^18.2.0",
         "react-dom": "^18.2.0",
-        "react-leaflet": "^4.2.1"
+        "react-leaflet": "^4.2.1",
+        "react-router-dom": "^7.9.5"
       },
       "devDependencies": {
         "@types/react": "^18.2.43",
@@ -1565,6 +1566,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/cookie": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-1.0.2.tgz",
+      "integrity": "sha512-9Kr/j4O16ISv8zBBhJoi4bXOYNTkFLOqSL3UDB0njXxCXNezjeyVrJyGOWtgfs/q2km1gwBcfH8q1yEGoMYunA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -2525,6 +2535,44 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/react-router": {
+      "version": "7.9.5",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.9.5.tgz",
+      "integrity": "sha512-JmxqrnBZ6E9hWmf02jzNn9Jm3UqyeimyiwzD69NjxGySG6lIz/1LVPsoTCwN7NBX2XjCEa1LIX5EMz1j2b6u6A==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie": "^1.0.1",
+        "set-cookie-parser": "^2.6.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      },
+      "peerDependenciesMeta": {
+        "react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/react-router-dom": {
+      "version": "7.9.5",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.9.5.tgz",
+      "integrity": "sha512-mkEmq/K8tKN63Ae2M7Xgz3c9l9YNbY+NHH6NNeUmLA3kDkhKXRsNb/ZpxaEunvGo2/3YXdk5EJU3Hxp3ocaBPw==",
+      "license": "MIT",
+      "dependencies": {
+        "react-router": "7.9.5"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      },
+      "peerDependencies": {
+        "react": ">=18",
+        "react-dom": ">=18"
+      }
+    },
     "node_modules/read-cache": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
@@ -2665,6 +2713,12 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/set-cookie-parser": {
+      "version": "2.7.2",
+      "resolved": "https://registry.npmjs.org/set-cookie-parser/-/set-cookie-parser-2.7.2.tgz",
+      "integrity": "sha512-oeM1lpU/UvhTxw+g3cIfxXHyJRc/uidd3yK1P242gzHds0udQBYzs3y8j4gCCW+ZJ7ad0yctld8RYO+bdurlvw==",
+      "license": "MIT"
+    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
diff --git a/package.json b/package.json
index 4867e42..9b1da41 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
-  "name": "kumamoto-travel-planner",
+  "name": "travel-planner",
   "private": true,
-  "version": "1.0.0",
+  "version": "2.0.0",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -14,7 +14,8 @@
     "leaflet": "^1.9.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-leaflet": "^4.2.1"
+    "react-leaflet": "^4.2.1",
+    "react-router-dom": "^7.9.5"
   },
   "devDependencies": {
     "@types/react": "^18.2.43",
diff --git a/server/Dockerfile b/server/Dockerfile
new file mode 100644
index 0000000..8f4fb02
--- /dev/null
+++ b/server/Dockerfile
@@ -0,0 +1,27 @@
+# API Server Dockerfile
+FROM node:18-alpine
+
+# 작업 디렉토리 설정
+WORKDIR /app
+
+# 패키지 파일 복사
+COPY package*.json ./
+
+# 의존성 설치
+RUN npm ci --only=production
+
+# 소스 코드 복사
+COPY . .
+
+# 업로드 디렉토리 생성
+RUN mkdir -p uploads
+
+# 포트 노출
+EXPOSE 3000
+
+# 헬스체크
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+  CMD curl -f http://localhost:3000/health || exit 1
+
+# 서버 시작
+CMD ["npm", "start"]
diff --git a/server/db.js b/server/db.js
new file mode 100644
index 0000000..c41cb77
--- /dev/null
+++ b/server/db.js
@@ -0,0 +1,45 @@
+const { Pool } = require('pg');
+const fs = require('fs');
+const path = require('path');
+
+// PostgreSQL 연결 풀 생성
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+// 데이터베이스 초기화 (테이블 생성)
+async function initializeDatabase() {
+  try {
+    // v2 스키마 사용 (새로운 멀티유저 시스템)
+    const schemaPath = fs.existsSync(path.join(__dirname, 'schema_v2.sql')) 
+      ? 'schema_v2.sql' 
+      : 'schema.sql';
+    
+    const schema = fs.readFileSync(path.join(__dirname, schemaPath), 'utf8');
+    await pool.query(schema);
+    console.log(`✅ Database tables initialized successfully (${schemaPath})`);
+  } catch (error) {
+    console.error('❌ Error initializing database:', error);
+    throw error;
+  }
+}
+
+// 쿼리 실행 헬퍼 함수
+async function query(text, params) {
+  const start = Date.now();
+  try {
+    const res = await pool.query(text, params);
+    const duration = Date.now() - start;
+    console.log('Executed query', { text, duration, rows: res.rowCount });
+    return res;
+  } catch (error) {
+    console.error('Query error:', error);
+    throw error;
+  }
+}
+
+module.exports = {
+  query,
+  pool,
+  initializeDatabase,
+};
diff --git a/server/env.example b/server/env.example
new file mode 100644
index 0000000..f8c9460
--- /dev/null
+++ b/server/env.example
@@ -0,0 +1,18 @@
+# Database Configuration
+DATABASE_URL=postgresql://username:password@localhost:5432/kumamoto_travel
+
+# JWT Configuration
+JWT_SECRET=your-super-secret-jwt-key-change-this-in-production
+
+# Google Maps API (Optional)
+GOOGLE_MAPS_API_KEY=your-google-maps-api-key
+
+# Email Configuration (Optional)
+SMTP_HOST=smtp.gmail.com
+SMTP_PORT=587
+SMTP_USER=your-email@gmail.com
+SMTP_PASS=your-app-password
+
+# Server Configuration
+PORT=3000
+NODE_ENV=development
diff --git a/server/migrate.js b/server/migrate.js
new file mode 100644
index 0000000..d137479
--- /dev/null
+++ b/server/migrate.js
@@ -0,0 +1,80 @@
+const { query } = require('./db');
+const fs = require('fs');
+const path = require('path');
+
+async function runMigrations() {
+  try {
+    console.log('🔄 데이터베이스 마이그레이션 시작...');
+
+    // 마이그레이션 디렉토리 확인
+    const migrationsDir = path.join(__dirname, 'migrations');
+    if (!fs.existsSync(migrationsDir)) {
+      console.log('📁 마이그레이션 디렉토리가 없습니다. 건너뜁니다.');
+      return;
+    }
+
+    // 마이그레이션 파일 목록
+    const migrationFiles = fs.readdirSync(migrationsDir)
+      .filter(file => file.endsWith('.sql'))
+      .sort();
+
+    if (migrationFiles.length === 0) {
+      console.log('📄 실행할 마이그레이션이 없습니다.');
+      return;
+    }
+
+    // 마이그레이션 테이블 생성
+    await query(`
+      CREATE TABLE IF NOT EXISTS migrations (
+        id SERIAL PRIMARY KEY,
+        filename VARCHAR(255) UNIQUE NOT NULL,
+        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+    // 각 마이그레이션 실행
+    for (const filename of migrationFiles) {
+      // 이미 실행된 마이그레이션인지 확인
+      const existingResult = await query(
+        'SELECT id FROM migrations WHERE filename = $1',
+        [filename]
+      );
+
+      if (existingResult.rows.length > 0) {
+        console.log(`⏭️  ${filename} - 이미 실행됨`);
+        continue;
+      }
+
+      console.log(`🔧 ${filename} 실행 중...`);
+
+      // 마이그레이션 파일 읽기 및 실행
+      const migrationPath = path.join(migrationsDir, filename);
+      const migrationSQL = fs.readFileSync(migrationPath, 'utf8');
+
+      await query(migrationSQL);
+
+      // 마이그레이션 기록
+      await query(
+        'INSERT INTO migrations (filename) VALUES ($1)',
+        [filename]
+      );
+
+      console.log(`✅ ${filename} 완료`);
+    }
+
+    console.log('🎉 모든 마이그레이션이 완료되었습니다!');
+
+  } catch (error) {
+    console.error('❌ 마이그레이션 실패:', error);
+    throw error;
+  }
+}
+
+// 직접 실행 시
+if (require.main === module) {
+  runMigrations()
+    .then(() => process.exit(0))
+    .catch(() => process.exit(1));
+}
+
+module.exports = { runMigrations };
diff --git a/server/migrations/001_add_user_system.sql b/server/migrations/001_add_user_system.sql
new file mode 100644
index 0000000..0aba88d
--- /dev/null
+++ b/server/migrations/001_add_user_system.sql
@@ -0,0 +1,129 @@
+-- 기존 DB에 사용자 시스템 추가 마이그레이션
+
+-- 사용자 테이블 추가
+CREATE TABLE IF NOT EXISTS users (
+  id SERIAL PRIMARY KEY,
+  email VARCHAR(255) UNIQUE NOT NULL,
+  password_hash VARCHAR(255) NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  role VARCHAR(20) DEFAULT 'user' CHECK (role IN ('admin', 'user')),
+  is_active BOOLEAN DEFAULT true,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  last_login TIMESTAMP
+);
+
+-- 기존 travel_plans 테이블에 컬럼 추가 (안전하게 하나씩)
+DO $$ 
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='user_id') THEN
+    ALTER TABLE travel_plans ADD COLUMN user_id INTEGER REFERENCES users(id) ON DELETE SET NULL;
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='title') THEN
+    ALTER TABLE travel_plans ADD COLUMN title VARCHAR(255) DEFAULT 'Untitled Trip';
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='description') THEN
+    ALTER TABLE travel_plans ADD COLUMN description TEXT;
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='destination') THEN
+    ALTER TABLE travel_plans ADD COLUMN destination VARCHAR(255) DEFAULT 'Kumamoto';
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='is_public') THEN
+    ALTER TABLE travel_plans ADD COLUMN is_public BOOLEAN DEFAULT false;
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='is_template') THEN
+    ALTER TABLE travel_plans ADD COLUMN is_template BOOLEAN DEFAULT false;
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='template_category') THEN
+    ALTER TABLE travel_plans ADD COLUMN template_category VARCHAR(20);
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='tags') THEN
+    ALTER TABLE travel_plans ADD COLUMN tags TEXT[] DEFAULT '{}';
+  END IF;
+  
+  IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name='travel_plans' AND column_name='status') THEN
+    ALTER TABLE travel_plans ADD COLUMN status VARCHAR(20) DEFAULT 'draft';
+  END IF;
+END $$;
+
+-- 공유 링크 테이블 추가
+CREATE TABLE IF NOT EXISTS share_links (
+  id SERIAL PRIMARY KEY,
+  trip_id INTEGER NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  created_by INTEGER NOT NULL REFERENCES users(id),
+  share_code VARCHAR(8) UNIQUE NOT NULL,
+  expires_at TIMESTAMP,
+  is_active BOOLEAN DEFAULT true,
+  access_count INTEGER DEFAULT 0,
+  max_access_count INTEGER,
+  can_view BOOLEAN DEFAULT true,
+  can_edit BOOLEAN DEFAULT false,
+  can_comment BOOLEAN DEFAULT false,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  last_accessed TIMESTAMP
+);
+
+-- 댓글 테이블 추가
+CREATE TABLE IF NOT EXISTS trip_comments (
+  id SERIAL PRIMARY KEY,
+  trip_id INTEGER NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  user_id INTEGER NOT NULL REFERENCES users(id),
+  content TEXT NOT NULL,
+  is_edited BOOLEAN DEFAULT false,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 시스템 설정 테이블 추가
+CREATE TABLE IF NOT EXISTS system_settings (
+  key VARCHAR(100) PRIMARY KEY,
+  value TEXT,
+  description TEXT,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 인덱스 추가
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+CREATE INDEX IF NOT EXISTS idx_users_role ON users(role);
+CREATE INDEX IF NOT EXISTS idx_travel_plans_user ON travel_plans(user_id);
+CREATE INDEX IF NOT EXISTS idx_travel_plans_status ON travel_plans(status);
+CREATE INDEX IF NOT EXISTS idx_share_links_code ON share_links(share_code);
+CREATE INDEX IF NOT EXISTS idx_share_links_trip ON share_links(trip_id);
+CREATE INDEX IF NOT EXISTS idx_comments_trip ON trip_comments(trip_id);
+
+-- 초기 시스템 설정
+INSERT INTO system_settings (key, value, description) VALUES
+  ('app_version', '2.0.0', '애플리케이션 버전'),
+  ('setup_completed', 'false', '초기 설정 완료 여부'),
+  ('jwt_secret_set', 'false', 'JWT 시크릿 설정 여부')
+ON CONFLICT (key) DO NOTHING;
+
+-- 업데이트 트리거 함수
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = CURRENT_TIMESTAMP;
+  RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- 업데이트 트리거 적용
+DROP TRIGGER IF EXISTS update_users_updated_at ON users;
+CREATE TRIGGER update_users_updated_at BEFORE UPDATE ON users FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_travel_plans_updated_at ON travel_plans;
+CREATE TRIGGER update_travel_plans_updated_at BEFORE UPDATE ON travel_plans FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_comments_updated_at ON trip_comments;
+CREATE TRIGGER update_comments_updated_at BEFORE UPDATE ON trip_comments FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_settings_updated_at ON system_settings;
+CREATE TRIGGER update_settings_updated_at BEFORE UPDATE ON system_settings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
diff --git a/server/package-lock.json b/server/package-lock.json
new file mode 100644
index 0000000..a30ba4f
--- /dev/null
+++ b/server/package-lock.json
@@ -0,0 +1,2154 @@
+{
+  "name": "travel-planner-api",
+  "version": "2.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "travel-planner-api",
+      "version": "2.0.0",
+      "dependencies": {
+        "bcrypt": "^5.1.1",
+        "cors": "^2.8.5",
+        "dotenv": "^16.3.1",
+        "express": "^4.18.2",
+        "jsonwebtoken": "^9.0.2",
+        "multer": "^2.0.2",
+        "pg": "^8.11.3"
+      },
+      "devDependencies": {
+        "nodemon": "^3.0.2"
+      }
+    },
+    "node_modules/@mapbox/node-pre-gyp": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.11.tgz",
+      "integrity": "sha512-Yhlar6v9WQgUp/He7BdgzOz8lqMQ8sU+jkCq7Wx8Myc5YFJLbEe7lgui/V7G1qB1DJykHSGwreceSaD60Y0PUQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "detect-libc": "^2.0.0",
+        "https-proxy-agent": "^5.0.0",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.7",
+        "nopt": "^5.0.0",
+        "npmlog": "^5.0.1",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.5",
+        "tar": "^6.1.11"
+      },
+      "bin": {
+        "node-pre-gyp": "bin/node-pre-gyp"
+      }
+    },
+    "node_modules/abbrev": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz",
+      "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==",
+      "license": "ISC"
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/agent-base/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/agent-base/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/append-field": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
+      "integrity": "sha512-klpgFSWLW1ZEs8svjfb7g4qWY0YS5imI82dTg+QahUvJ8YqAY0P10Uk8tTyh9ZGuYEZEMaeJYCF5BFuX552hsw==",
+      "license": "MIT"
+    },
+    "node_modules/aproba": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/aproba/-/aproba-2.1.0.tgz",
+      "integrity": "sha512-tLIEcj5GuR2RSTnxNKdkK0dJ/GrC7P38sUkiDmDuHfsHmbagTFAxDVIBltoklXEVIQ/f14IL8IMJ5pn9Hez1Ew==",
+      "license": "ISC"
+    },
+    "node_modules/are-we-there-yet": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/are-we-there-yet/-/are-we-there-yet-2.0.0.tgz",
+      "integrity": "sha512-Ci/qENmwHnsYo9xKIcUJN5LeDKdJ6R1Z1j9V/J5wyq8nh/mYPEpIKJbBZXtZjG04HiK7zV/p6Vs9952MrMeUIw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "delegates": "^1.0.0",
+        "readable-stream": "^3.6.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/bcrypt": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-5.1.1.tgz",
+      "integrity": "sha512-AGBHOG5hPYZ5Xl9KXzU5iKq9516yEmvCKDg3ecP5kX2aB6UqTeXZxk2ELnDgDm6BQSMlLt9rDB4LoSMx0rYwww==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "@mapbox/node-pre-gyp": "^1.0.11",
+        "node-addon-api": "^5.0.0"
+      },
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.13.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/buffer-equal-constant-time": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz",
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "license": "MIT"
+    },
+    "node_modules/busboy": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/busboy/-/busboy-1.6.0.tgz",
+      "integrity": "sha512-8SFQbg/0hQ9xy3UNTB0YEnsNBbWfhf7RtnzpL7TkBiTBRfrQ9Fxcnz7VJsleJpyp6rVLvXiuORqjlHi5q+PYuA==",
+      "dependencies": {
+        "streamsearch": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=10.16.0"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chownr": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+      "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/color-support": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-support/-/color-support-1.1.3.tgz",
+      "integrity": "sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==",
+      "license": "ISC",
+      "bin": {
+        "color-support": "bin.js"
+      }
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "license": "MIT"
+    },
+    "node_modules/concat-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-2.0.0.tgz",
+      "integrity": "sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A==",
+      "engines": [
+        "node >= 6.0"
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "inherits": "^2.0.3",
+        "readable-stream": "^3.0.2",
+        "typedarray": "^0.0.6"
+      }
+    },
+    "node_modules/console-control-strings": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/console-control-strings/-/console-control-strings-1.1.0.tgz",
+      "integrity": "sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==",
+      "license": "ISC"
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/delegates": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delegates/-/delegates-1.0.0.tgz",
+      "integrity": "sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==",
+      "license": "MIT"
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ecdsa-sig-formatter": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz",
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.21.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
+      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.3",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.3.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fs-minipass": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+      "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/fs-minipass/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "license": "ISC"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gauge": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/gauge/-/gauge-3.0.2.tgz",
+      "integrity": "sha512-+5J6MS/5XksCuXq++uFRsnUd7Ovu1XenbeuIuNRJxYWjgQbPuFhT14lAvsWfqfAmnwluf1OwMjz39HjfLPci0Q==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "aproba": "^1.0.3 || ^2.0.0",
+        "color-support": "^1.1.2",
+        "console-control-strings": "^1.0.0",
+        "has-unicode": "^2.0.1",
+        "object-assign": "^4.1.1",
+        "signal-exit": "^3.0.0",
+        "string-width": "^4.2.3",
+        "strip-ansi": "^6.0.1",
+        "wide-align": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-unicode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
+      "integrity": "sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==",
+      "license": "ISC"
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz",
+      "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/https-proxy-agent/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/ignore-by-default": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/ignore-by-default/-/ignore-by-default-1.0.1.tgz",
+      "integrity": "sha512-Ius2VYcGNk7T90CppJqcIkS5ooHUZyIQK+ClZfMfMNFEF9VSE73Fq+906u/CWu92x4gzZMWOwfFYckPObzdEbA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/jsonwebtoken": {
+      "version": "9.0.2",
+      "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.2.tgz",
+      "integrity": "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==",
+      "license": "MIT",
+      "dependencies": {
+        "jws": "^3.2.2",
+        "lodash.includes": "^4.3.0",
+        "lodash.isboolean": "^3.0.3",
+        "lodash.isinteger": "^4.0.4",
+        "lodash.isnumber": "^3.0.3",
+        "lodash.isplainobject": "^4.0.6",
+        "lodash.isstring": "^4.0.1",
+        "lodash.once": "^4.0.0",
+        "ms": "^2.1.1",
+        "semver": "^7.5.4"
+      },
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      }
+    },
+    "node_modules/jsonwebtoken/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/jwa": {
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/jwa/-/jwa-1.4.2.tgz",
+      "integrity": "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==",
+      "license": "MIT",
+      "dependencies": {
+        "buffer-equal-constant-time": "^1.0.1",
+        "ecdsa-sig-formatter": "1.0.11",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/jws": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/jws/-/jws-3.2.2.tgz",
+      "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==",
+      "license": "MIT",
+      "dependencies": {
+        "jwa": "^1.4.1",
+        "safe-buffer": "^5.0.1"
+      }
+    },
+    "node_modules/lodash.includes": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz",
+      "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isboolean": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz",
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isinteger": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz",
+      "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isnumber": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz",
+      "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isplainobject": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.isstring": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz",
+      "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.once": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz",
+      "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==",
+      "license": "MIT"
+    },
+    "node_modules/make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/make-dir/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-5.0.0.tgz",
+      "integrity": "sha512-3FnjYuehv9k6ovOEbyOswadCDPX1piCfhV8ncmYtHOjuPwylVWsghTLo7rabjC3Rx5xD4HDx8Wm1xnMF7S5qFQ==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+      "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^3.0.0",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/minizlib/node_modules/minipass": {
+      "version": "3.3.6",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+      "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/mkdirp": {
+      "version": "0.5.6",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
+      "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+      "license": "MIT",
+      "dependencies": {
+        "minimist": "^1.2.6"
+      },
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/multer": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/multer/-/multer-2.0.2.tgz",
+      "integrity": "sha512-u7f2xaZ/UG8oLXHvtF/oWTRvT44p9ecwBBqTwgJVq0+4BW1g8OW01TyMEGWBHbyMOYVHXslaut7qEQ1meATXgw==",
+      "license": "MIT",
+      "dependencies": {
+        "append-field": "^1.0.0",
+        "busboy": "^1.6.0",
+        "concat-stream": "^2.0.0",
+        "mkdirp": "^0.5.6",
+        "object-assign": "^4.1.1",
+        "type-is": "^1.6.18",
+        "xtend": "^4.0.2"
+      },
+      "engines": {
+        "node": ">= 10.16.0"
+      }
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/node-addon-api": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-5.1.0.tgz",
+      "integrity": "sha512-eh0GgfEkpnoWDq+VY8OyvYhFEzBk6jIYbRKdIlyTiAXIVJ8PyBaKb0rp7oDtoddbdoHWhq8wwr+XZ81F1rpNdA==",
+      "license": "MIT"
+    },
+    "node_modules/node-fetch": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
+      "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-url": "^5.0.0"
+      },
+      "engines": {
+        "node": "4.x || >=6.0.0"
+      },
+      "peerDependencies": {
+        "encoding": "^0.1.0"
+      },
+      "peerDependenciesMeta": {
+        "encoding": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon": {
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/nodemon/-/nodemon-3.1.10.tgz",
+      "integrity": "sha512-WDjw3pJ0/0jMFmyNDp3gvY2YizjLmmOUQo6DEBY+JgdvW/yQ9mEeSw6H5ythl5Ny2ytb7f9C2nIbjSxMNzbJXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "debug": "^4",
+        "ignore-by-default": "^1.0.1",
+        "minimatch": "^3.1.2",
+        "pstree.remy": "^1.1.8",
+        "semver": "^7.5.3",
+        "simple-update-notifier": "^2.0.0",
+        "supports-color": "^5.5.0",
+        "touch": "^3.1.0",
+        "undefsafe": "^2.0.5"
+      },
+      "bin": {
+        "nodemon": "bin/nodemon.js"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/nodemon"
+      }
+    },
+    "node_modules/nodemon/node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nodemon/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nopt": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+      "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+      "license": "ISC",
+      "dependencies": {
+        "abbrev": "1"
+      },
+      "bin": {
+        "nopt": "bin/nopt.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/npmlog": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-5.0.1.tgz",
+      "integrity": "sha512-AqZtDUWOMKs1G/8lwylVjrdYgqA4d9nu8hc+0gzRxlDb1I10+FHBGMXs6aiQHFdCUUlqH99MUMuLfzWDNDtfxw==",
+      "deprecated": "This package is no longer supported.",
+      "license": "ISC",
+      "dependencies": {
+        "are-we-there-yet": "^2.0.0",
+        "console-control-strings": "^1.1.0",
+        "gauge": "^3.0.0",
+        "set-blocking": "^2.0.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+      "license": "MIT"
+    },
+    "node_modules/pg": {
+      "version": "8.16.3",
+      "resolved": "https://registry.npmjs.org/pg/-/pg-8.16.3.tgz",
+      "integrity": "sha512-enxc1h0jA/aq5oSDMvqyW3q89ra6XIIDZgCX9vkMrnz5DFTw/Ny3Li2lFQ+pt3L6MCgm/5o2o8HW9hiJji+xvw==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-connection-string": "^2.9.1",
+        "pg-pool": "^3.10.1",
+        "pg-protocol": "^1.10.3",
+        "pg-types": "2.2.0",
+        "pgpass": "1.0.5"
+      },
+      "engines": {
+        "node": ">= 16.0.0"
+      },
+      "optionalDependencies": {
+        "pg-cloudflare": "^1.2.7"
+      },
+      "peerDependencies": {
+        "pg-native": ">=3.0.1"
+      },
+      "peerDependenciesMeta": {
+        "pg-native": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/pg-cloudflare": {
+      "version": "1.2.7",
+      "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.2.7.tgz",
+      "integrity": "sha512-YgCtzMH0ptvZJslLM1ffsY4EuGaU0cx4XSdXLRFae8bPP4dS5xL1tNB3k2o/N64cHJpwU7dxKli/nZ2lUa5fLg==",
+      "license": "MIT",
+      "optional": true
+    },
+    "node_modules/pg-connection-string": {
+      "version": "2.9.1",
+      "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.9.1.tgz",
+      "integrity": "sha512-nkc6NpDcvPVpZXxrreI/FOtX3XemeLl8E0qFr6F2Lrm/I8WOnaWNhIPK2Z7OHpw7gh5XJThi6j6ppgNoaT1w4w==",
+      "license": "MIT"
+    },
+    "node_modules/pg-int8": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
+      "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=4.0.0"
+      }
+    },
+    "node_modules/pg-pool": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.10.1.tgz",
+      "integrity": "sha512-Tu8jMlcX+9d8+QVzKIvM/uJtp07PKr82IUOYEphaWcoBhIYkoHpLXN3qO59nAI11ripznDsEzEv8nUxBVWajGg==",
+      "license": "MIT",
+      "peerDependencies": {
+        "pg": ">=8.0"
+      }
+    },
+    "node_modules/pg-protocol": {
+      "version": "1.10.3",
+      "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.10.3.tgz",
+      "integrity": "sha512-6DIBgBQaTKDJyxnXaLiLR8wBpQQcGWuAESkRBX/t6OwA8YsqP+iVSiond2EDy6Y/dsGk8rh/jtax3js5NeV7JQ==",
+      "license": "MIT"
+    },
+    "node_modules/pg-types": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
+      "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
+      "license": "MIT",
+      "dependencies": {
+        "pg-int8": "1.0.1",
+        "postgres-array": "~2.0.0",
+        "postgres-bytea": "~1.0.0",
+        "postgres-date": "~1.0.4",
+        "postgres-interval": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/pgpass": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
+      "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
+      "license": "MIT",
+      "dependencies": {
+        "split2": "^4.1.0"
+      }
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+      "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postgres-array": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
+      "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postgres-bytea": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.0.tgz",
+      "integrity": "sha512-xy3pmLuQqRBZBXDULy7KbaitYqLcmxigw14Q5sj8QBVLqEwXfeybIKVWiqAXTlcvdvb0+xkOtDbfQMOf4lST1w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-date": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
+      "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/postgres-interval": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
+      "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "xtend": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/pstree.remy": {
+      "version": "1.1.8",
+      "resolved": "https://registry.npmjs.org/pstree.remy/-/pstree.remy-1.1.8.tgz",
+      "integrity": "sha512-77DZwxQmxKnu3aR542U+X8FypNzbfJ+C5XQDk3uWjWxn6151aIMGthWYRXTqT1E5oJvg+ljaa2OJi+VfvCOQ8w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/readable-stream": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+      "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+      "license": "MIT",
+      "dependencies": {
+        "inherits": "^2.0.3",
+        "string_decoder": "^1.1.1",
+        "util-deprecate": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "deprecated": "Rimraf versions prior to v4 are no longer supported",
+      "license": "ISC",
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "7.7.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz",
+      "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/send": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.19.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/set-blocking": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
+      "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==",
+      "license": "ISC"
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/signal-exit": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+      "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+      "license": "ISC"
+    },
+    "node_modules/simple-update-notifier": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+      "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "semver": "^7.5.3"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/split2": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
+      "license": "ISC",
+      "engines": {
+        "node": ">= 10.x"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/streamsearch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/streamsearch/-/streamsearch-1.1.0.tgz",
+      "integrity": "sha512-Mcc5wHehp9aXz1ax6bZUyY5afg9u2rv5cqQI3mRrYkGC8rW2hM02jWuwjtL++LS5qinSyhj2QfLyNsuc+VsExg==",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/string_decoder": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+      "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.2.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/tar": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
+      "integrity": "sha512-DZ4yORTwrbTj/7MZYq2w+/ZFdI6OZ/f9SFHR+71gIVUZhOQPHzVCLpvRnPgyaMpfWxxk/4ONva3GQSyNIKRv6A==",
+      "license": "ISC",
+      "dependencies": {
+        "chownr": "^2.0.0",
+        "fs-minipass": "^2.0.0",
+        "minipass": "^5.0.0",
+        "minizlib": "^2.1.1",
+        "mkdirp": "^1.0.3",
+        "yallist": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/tar/node_modules/mkdirp": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+      "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==",
+      "license": "MIT",
+      "bin": {
+        "mkdirp": "bin/cmd.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/touch": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/touch/-/touch-3.1.1.tgz",
+      "integrity": "sha512-r0eojU4bI8MnHr8c5bNo7lJDdI2qXlWWJk6a9EAFG7vbhTjElYhBVS3/miuE0uOuoLdb8Mc/rVfsmm6eo5o9GA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "nodetouch": "bin/nodetouch.js"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "0.0.3",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
+      "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
+      "license": "MIT"
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/typedarray": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz",
+      "integrity": "sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA==",
+      "license": "MIT"
+    },
+    "node_modules/undefsafe": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/undefsafe/-/undefsafe-2.0.5.tgz",
+      "integrity": "sha512-WxONCrssBM8TSPRqN5EmsjVrsv4A8X12J4ArBiiayv3DyyG3ZlIg6yysuuSYdZsVz3TKcTg2fd//Ujd4CHV1iA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
+      "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/whatwg-url": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
+      "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "~0.0.3",
+        "webidl-conversions": "^3.0.0"
+      }
+    },
+    "node_modules/wide-align": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.5.tgz",
+      "integrity": "sha512-eDMORYaPNZ4sQIuuYPDHdQvf4gyCF9rEEV/yPxGfwPkRodwEgiMUUXTx/dex+Me0wxx53S+NgUHaP7y3MGlDmg==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^1.0.2 || 2 || 3 || 4"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/xtend": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4"
+      }
+    },
+    "node_modules/yallist": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+      "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+      "license": "ISC"
+    }
+  }
+}
diff --git a/server/package.json b/server/package.json
new file mode 100644
index 0000000..b6a8b9c
--- /dev/null
+++ b/server/package.json
@@ -0,0 +1,22 @@
+{
+  "name": "travel-planner-api",
+  "version": "2.0.0",
+  "description": "Backend API for Travel Planner - Multi-user travel planning system",
+  "main": "server.js",
+  "scripts": {
+    "dev": "nodemon server.js",
+    "start": "node server.js"
+  },
+  "dependencies": {
+    "bcrypt": "^5.1.1",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.0.2",
+    "pg": "^8.11.3"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+}
diff --git a/server/routes/auth.js b/server/routes/auth.js
new file mode 100644
index 0000000..3866d9e
--- /dev/null
+++ b/server/routes/auth.js
@@ -0,0 +1,179 @@
+const express = require('express');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+const { query } = require('../db');
+
+const router = express.Router();
+
+// JWT 시크릿 (환경변수에서 가져오거나 기본값 사용)
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-this-in-production';
+
+// 회원가입
+router.post('/register', async (req, res) => {
+  try {
+    const { email, password, name } = req.body;
+
+    // 이메일 중복 확인
+    const existingUser = await query('SELECT id FROM users WHERE email = $1', [email]);
+    if (existingUser.rows.length > 0) {
+      return res.status(400).json({ success: false, message: '이미 사용 중인 이메일입니다' });
+    }
+
+    // 비밀번호 해시
+    const saltRounds = 10;
+    const passwordHash = await bcrypt.hash(password, saltRounds);
+
+    // 사용자 생성
+    const result = await query(
+      'INSERT INTO users (email, password_hash, name) VALUES ($1, $2, $3) RETURNING id, email, name, role, created_at',
+      [email, passwordHash, name]
+    );
+
+    const user = result.rows[0];
+
+    // JWT 토큰 생성
+    const token = jwt.sign(
+      { userId: user.id, email: user.email, role: user.role },
+      JWT_SECRET,
+      { expiresIn: '7d' }
+    );
+
+    res.json({
+      success: true,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role,
+        created_at: user.created_at
+      },
+      token,
+      message: '회원가입이 완료되었습니다'
+    });
+  } catch (error) {
+    console.error('Registration error:', error);
+    res.status(500).json({ success: false, message: '회원가입 중 오류가 발생했습니다' });
+  }
+});
+
+// 로그인
+router.post('/login', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    // 사용자 조회
+    const result = await query(
+      'SELECT id, email, password_hash, name, role, is_active FROM users WHERE email = $1',
+      [email]
+    );
+
+    if (result.rows.length === 0) {
+      return res.status(400).json({ success: false, message: '등록되지 않은 이메일입니다' });
+    }
+
+    const user = result.rows[0];
+
+    if (!user.is_active) {
+      return res.status(400).json({ success: false, message: '비활성화된 계정입니다' });
+    }
+
+    // 비밀번호 확인
+    const isValidPassword = await bcrypt.compare(password, user.password_hash);
+    if (!isValidPassword) {
+      return res.status(400).json({ success: false, message: '비밀번호가 올바르지 않습니다' });
+    }
+
+    // 마지막 로그인 시간 업데이트
+    await query('UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = $1', [user.id]);
+
+    // JWT 토큰 생성
+    const token = jwt.sign(
+      { userId: user.id, email: user.email, role: user.role },
+      JWT_SECRET,
+      { expiresIn: '7d' }
+    );
+
+    res.json({
+      success: true,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role,
+        is_active: user.is_active
+      },
+      token,
+      message: '로그인되었습니다'
+    });
+  } catch (error) {
+    console.error('Login error:', error);
+    res.status(500).json({ success: false, message: '로그인 중 오류가 발생했습니다' });
+  }
+});
+
+// 토큰 검증
+router.get('/verify', authenticateToken, async (req, res) => {
+  try {
+    const result = await query(
+      'SELECT id, email, name, role, is_active, last_login FROM users WHERE id = $1',
+      [req.user.userId]
+    );
+
+    if (result.rows.length === 0) {
+      return res.status(404).json({ success: false, message: '사용자를 찾을 수 없습니다' });
+    }
+
+    const user = result.rows[0];
+
+    if (!user.is_active) {
+      return res.status(403).json({ success: false, message: '비활성화된 계정입니다' });
+    }
+
+    res.json({
+      success: true,
+      user: {
+        id: user.id,
+        email: user.email,
+        name: user.name,
+        role: user.role,
+        is_active: user.is_active,
+        last_login: user.last_login
+      }
+    });
+  } catch (error) {
+    console.error('Token verification error:', error);
+    res.status(500).json({ success: false, message: '토큰 검증 중 오류가 발생했습니다' });
+  }
+});
+
+// JWT 토큰 인증 미들웨어
+function authenticateToken(req, res, next) {
+  const authHeader = req.headers['authorization'];
+  const token = authHeader && authHeader.split(' ')[1];
+
+  if (!token) {
+    return res.status(401).json({ success: false, message: '액세스 토큰이 필요합니다' });
+  }
+
+  jwt.verify(token, JWT_SECRET, (err, user) => {
+    if (err) {
+      return res.status(403).json({ success: false, message: '유효하지 않은 토큰입니다' });
+    }
+    req.user = user;
+    next();
+  });
+}
+
+// 관리자 권한 확인 미들웨어
+function requireAdmin(req, res, next) {
+  if (req.user.role !== 'admin') {
+    return res.status(403).json({ success: false, message: '관리자 권한이 필요합니다' });
+  }
+  next();
+}
+
+module.exports = {
+  router,
+  authenticateToken,
+  requireAdmin
+};
diff --git a/server/routes/basePoints.js b/server/routes/basePoints.js
new file mode 100644
index 0000000..d8f3527
--- /dev/null
+++ b/server/routes/basePoints.js
@@ -0,0 +1,77 @@
+const express = require('express');
+const { query } = require('../db');
+
+const router = express.Router();
+
+// 모든 기본 포인트 조회
+router.get('/', async (req, res) => {
+  try {
+    const result = await query(
+      'SELECT * FROM base_points ORDER BY created_at DESC'
+    );
+
+    const basePoints = result.rows.map(row => ({
+      id: row.id.toString(),
+      name: row.name,
+      address: row.address,
+      type: row.type,
+      coordinates: {
+        lat: parseFloat(row.lat),
+        lng: parseFloat(row.lng)
+      },
+      memo: row.memo
+    }));
+
+    res.json(basePoints);
+  } catch (error) {
+    console.error('Error fetching base points:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 기본 포인트 추가
+router.post('/', async (req, res) => {
+  try {
+    const { name, address, type, coordinates, memo } = req.body;
+
+    const result = await query(
+      `INSERT INTO base_points (name, address, type, lat, lng, memo)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       RETURNING *`,
+      [name, address || null, type, coordinates.lat, coordinates.lng, memo || null]
+    );
+
+    const basePoint = {
+      id: result.rows[0].id.toString(),
+      name: result.rows[0].name,
+      address: result.rows[0].address,
+      type: result.rows[0].type,
+      coordinates: {
+        lat: parseFloat(result.rows[0].lat),
+        lng: parseFloat(result.rows[0].lng)
+      },
+      memo: result.rows[0].memo
+    };
+
+    res.json(basePoint);
+  } catch (error) {
+    console.error('Error creating base point:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 기본 포인트 삭제
+router.delete('/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+
+    await query('DELETE FROM base_points WHERE id = $1', [id]);
+
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error deleting base point:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;
diff --git a/server/routes/setup.js b/server/routes/setup.js
new file mode 100644
index 0000000..be5363d
--- /dev/null
+++ b/server/routes/setup.js
@@ -0,0 +1,187 @@
+const express = require('express');
+const bcrypt = require('bcrypt');
+const { query } = require('../db');
+
+const router = express.Router();
+
+// 설정 상태 확인
+router.get('/status', async (req, res) => {
+  try {
+    // 시스템 설정 확인
+    const settingsResult = await query('SELECT key, value FROM system_settings');
+    const settings = {};
+    settingsResult.rows.forEach(row => {
+      settings[row.key] = row.value;
+    });
+
+    // 관리자 계정 존재 여부 확인
+    const adminResult = await query('SELECT COUNT(*) as count FROM users WHERE role = $1', ['admin']);
+    const hasAdmin = parseInt(adminResult.rows[0].count) > 0;
+
+    // 전체 사용자 수
+    const userCountResult = await query('SELECT COUNT(*) as count FROM users');
+    const totalUsers = parseInt(userCountResult.rows[0].count);
+
+    const isSetupComplete = settings.setup_completed === 'true' && hasAdmin;
+
+    res.json({
+      isSetupComplete,
+      is_setup_required: !isSetupComplete,
+      setup_step: isSetupComplete ? 'completed' : 'initial',
+      has_admin: hasAdmin,
+      total_users: totalUsers,
+      version: settings.app_version || '2.0.0',
+      settings: {
+        jwt_secret_set: settings.jwt_secret_set === 'true',
+        google_maps_configured: settings.google_maps_configured === 'true',
+        email_configured: settings.email_configured === 'true'
+      }
+    });
+  } catch (error) {
+    console.error('Setup status check error:', error);
+    res.status(500).json({
+      success: false,
+      message: '설정 상태 확인 중 오류가 발생했습니다',
+      error: error.message
+    });
+  }
+});
+
+// 초기 관리자 계정 생성
+router.post('/admin', async (req, res) => {
+  try {
+    const { name, email, password } = req.body;
+
+    // 입력 검증
+    if (!name || !email || !password) {
+      return res.status(400).json({
+        success: false,
+        message: '이름, 이메일, 비밀번호를 모두 입력해주세요'
+      });
+    }
+
+    // 이미 관리자가 있는지 확인
+    const existingAdmin = await query('SELECT id FROM users WHERE role = $1', ['admin']);
+    if (existingAdmin.rows.length > 0) {
+      return res.status(400).json({
+        success: false,
+        message: '이미 관리자 계정이 존재합니다'
+      });
+    }
+
+    // 이메일 중복 확인
+    const existingUser = await query('SELECT id FROM users WHERE email = $1', [email]);
+    if (existingUser.rows.length > 0) {
+      return res.status(400).json({
+        success: false,
+        message: '이미 사용 중인 이메일입니다'
+      });
+    }
+
+    // 비밀번호 해시
+    const saltRounds = 10;
+    const passwordHash = await bcrypt.hash(password, saltRounds);
+
+    // 관리자 계정 생성
+    const result = await query(
+      'INSERT INTO users (email, password_hash, name, role) VALUES ($1, $2, $3, $4) RETURNING id, email, name, role, created_at',
+      [email, passwordHash, name, 'admin']
+    );
+
+    const admin = result.rows[0];
+
+    // 설정 완료 표시
+    await query(
+      'UPDATE system_settings SET value = $1, updated_at = CURRENT_TIMESTAMP WHERE key = $2',
+      ['true', 'setup_completed']
+    );
+
+    res.json({
+      success: true,
+      message: '관리자 계정이 생성되었습니다',
+      admin: {
+        id: admin.id,
+        email: admin.email,
+        name: admin.name,
+        role: admin.role,
+        created_at: admin.created_at
+      }
+    });
+  } catch (error) {
+    console.error('Admin creation error:', error);
+    res.status(500).json({
+      success: false,
+      message: '관리자 계정 생성 중 오류가 발생했습니다',
+      error: error.message
+    });
+  }
+});
+
+// 환경 설정 업데이트
+router.post('/config', async (req, res) => {
+  try {
+    const { jwt_secret, google_maps_api_key, email_config } = req.body;
+
+    const updates = [];
+
+    // JWT 시크릿 설정
+    if (jwt_secret) {
+      process.env.JWT_SECRET = jwt_secret;
+      updates.push(['jwt_secret_set', 'true']);
+    }
+
+    // Google Maps API 키 설정
+    if (google_maps_api_key) {
+      process.env.GOOGLE_MAPS_API_KEY = google_maps_api_key;
+      updates.push(['google_maps_configured', 'true']);
+    }
+
+    // 이메일 설정
+    if (email_config) {
+      // 이메일 설정 로직 (SMTP 등)
+      updates.push(['email_configured', 'true']);
+    }
+
+    // 설정 업데이트
+    for (const [key, value] of updates) {
+      await query(
+        'UPDATE system_settings SET value = $1, updated_at = CURRENT_TIMESTAMP WHERE key = $2',
+        [value, key]
+      );
+    }
+
+    res.json({
+      success: true,
+      message: '환경 설정이 업데이트되었습니다',
+      updated: updates.map(([key]) => key)
+    });
+  } catch (error) {
+    console.error('Config update error:', error);
+    res.status(500).json({
+      success: false,
+      message: '환경 설정 업데이트 중 오류가 발생했습니다',
+      error: error.message
+    });
+  }
+});
+
+// 데이터베이스 연결 테스트
+router.get('/test-db', async (req, res) => {
+  try {
+    const result = await query('SELECT NOW() as current_time, version() as db_version');
+    res.json({
+      success: true,
+      message: '데이터베이스 연결 성공',
+      data: result.rows[0]
+    });
+  } catch (error) {
+    console.error('Database test error:', error);
+    res.status(500).json({
+      success: false,
+      message: '데이터베이스 연결 실패',
+      error: error.message
+    });
+  }
+});
+
+module.exports = router;
diff --git a/server/routes/travelPlans.js b/server/routes/travelPlans.js
new file mode 100644
index 0000000..48cdc7d
--- /dev/null
+++ b/server/routes/travelPlans.js
@@ -0,0 +1,183 @@
+const express = require('express');
+const { query } = require('../db');
+
+const router = express.Router();
+
+// 여행 계획 전체 조회 (최신 1개)
+router.get('/', async (req, res) => {
+  try {
+    // 최신 여행 계획 조회
+    const planResult = await query(
+      'SELECT * FROM travel_plans ORDER BY created_at DESC LIMIT 1'
+    );
+
+    if (planResult.rows.length === 0) {
+      return res.json(null);
+    }
+
+    const plan = planResult.rows[0];
+
+    // 해당 계획의 모든 일정 조회
+    const schedules = await query(
+      `SELECT ds.id, ds.schedule_date,
+              json_agg(
+                json_build_object(
+                  'id', a.id,
+                  'time', a.time,
+                  'title', a.title,
+                  'description', a.description,
+                  'location', a.location,
+                  'type', a.type,
+                  'coordinates', CASE
+                    WHEN a.lat IS NOT NULL AND a.lng IS NOT NULL
+                    THEN json_build_object('lat', a.lat, 'lng', a.lng)
+                    ELSE NULL
+                  END,
+                  'images', a.images,
+                  'links', a.links,
+                  'relatedPlaces', (
+                    SELECT json_agg(
+                      json_build_object(
+                        'id', rp.id,
+                        'name', rp.name,
+                        'description', rp.description,
+                        'address', rp.address,
+                        'coordinates', CASE
+                          WHEN rp.lat IS NOT NULL AND rp.lng IS NOT NULL
+                          THEN json_build_object('lat', rp.lat, 'lng', rp.lng)
+                          ELSE NULL
+                        END,
+                        'memo', rp.memo,
+                        'willVisit', rp.will_visit,
+                        'category', rp.category,
+                        'images', rp.images,
+                        'links', rp.links
+                      )
+                    )
+                    FROM related_places rp
+                    WHERE rp.activity_id = a.id
+                  )
+                ) ORDER BY a.time
+              ) FILTER (WHERE a.id IS NOT NULL) as activities
+       FROM day_schedules ds
+       LEFT JOIN activities a ON a.day_schedule_id = ds.id
+       WHERE ds.travel_plan_id = $1
+       GROUP BY ds.id, ds.schedule_date
+       ORDER BY ds.schedule_date`,
+      [plan.id]
+    );
+
+    const travelPlan = {
+      id: plan.id,
+      startDate: plan.start_date,
+      endDate: plan.end_date,
+      schedule: schedules.rows.map(row => ({
+        date: row.schedule_date,
+        activities: row.activities || []
+      })),
+      budget: {
+        total: 0,
+        accommodation: 0,
+        food: 0,
+        transportation: 0,
+        shopping: 0,
+        activities: 0
+      },
+      checklist: []
+    };
+
+    res.json(travelPlan);
+  } catch (error) {
+    console.error('Error fetching travel plan:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 여행 계획 저장/업데이트
+router.post('/', async (req, res) => {
+  const client = await query('BEGIN');
+
+  try {
+    const { startDate, endDate, schedule } = req.body;
+
+    // 기존 계획 삭제 (단순화: 항상 최신 1개만 유지)
+    await query('DELETE FROM travel_plans');
+
+    // 새 여행 계획 생성
+    const planResult = await query(
+      'INSERT INTO travel_plans (start_date, end_date) VALUES ($1, $2) RETURNING id',
+      [startDate, endDate]
+    );
+
+    const planId = planResult.rows[0].id;
+
+    // 일정별 데이터 삽입
+    for (const day of schedule) {
+      // day_schedule 삽입
+      const scheduleResult = await query(
+        'INSERT INTO day_schedules (travel_plan_id, schedule_date) VALUES ($1, $2) RETURNING id',
+        [planId, day.date]
+      );
+
+      const scheduleId = scheduleResult.rows[0].id;
+
+      // activities 삽입
+      if (day.activities && day.activities.length > 0) {
+        for (const activity of day.activities) {
+          const activityResult = await query(
+            `INSERT INTO activities (
+              day_schedule_id, time, title, description, location, type, lat, lng, images, links
+            ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) RETURNING id`,
+            [
+              scheduleId,
+              activity.time,
+              activity.title,
+              activity.description || null,
+              activity.location || null,
+              activity.type,
+              activity.coordinates?.lat || null,
+              activity.coordinates?.lng || null,
+              activity.images || null,
+              activity.links || null
+            ]
+          );
+
+          const activityId = activityResult.rows[0].id;
+
+          // related_places 삽입
+          if (activity.relatedPlaces && activity.relatedPlaces.length > 0) {
+            for (const place of activity.relatedPlaces) {
+              await query(
+                `INSERT INTO related_places (
+                  activity_id, name, description, address, lat, lng, memo, will_visit, category, images, links
+                ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
+                [
+                  activityId,
+                  place.name,
+                  place.description || null,
+                  place.address || null,
+                  place.coordinates?.lat || null,
+                  place.coordinates?.lng || null,
+                  place.memo || null,
+                  place.willVisit || false,
+                  place.category || 'other',
+                  place.images || null,
+                  place.links || null
+                ]
+              );
+            }
+          }
+        }
+      }
+    }
+
+    await query('COMMIT');
+    res.json({ success: true, id: planId });
+  } catch (error) {
+    await query('ROLLBACK');
+    console.error('Error saving travel plan:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;
diff --git a/server/routes/uploads.js b/server/routes/uploads.js
new file mode 100644
index 0000000..680304b
--- /dev/null
+++ b/server/routes/uploads.js
@@ -0,0 +1,88 @@
+const express = require('express');
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+const router = express.Router();
+
+// uploads 디렉토리 생성
+const uploadsDir = path.join(__dirname, '../uploads');
+if (!fs.existsSync(uploadsDir)) {
+  fs.mkdirSync(uploadsDir, { recursive: true });
+}
+
+// Multer 설정: 파일 저장 위치와 파일명 설정
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, uploadsDir);
+  },
+  filename: (req, file, cb) => {
+    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+    const ext = path.extname(file.originalname);
+    cb(null, file.fieldname + '-' + uniqueSuffix + ext);
+  }
+});
+
+// 파일 필터: 이미지만 허용
+const fileFilter = (req, file, cb) => {
+  const allowedTypes = /jpeg|jpg|png|gif|webp/;
+  const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
+  const mimetype = allowedTypes.test(file.mimetype);
+
+  if (mimetype && extname) {
+    return cb(null, true);
+  } else {
+    cb(new Error('이미지 파일만 업로드 가능합니다 (jpeg, jpg, png, gif, webp)'));
+  }
+};
+
+const upload = multer({
+  storage: storage,
+  limits: {
+    fileSize: 5 * 1024 * 1024 // 5MB 제한
+  },
+  fileFilter: fileFilter
+});
+
+// 다중 이미지 업로드 (최대 5개)
+router.post('/', upload.array('images', 5), (req, res) => {
+  try {
+    if (!req.files || req.files.length === 0) {
+      return res.status(400).json({ error: '파일이 업로드되지 않았습니다' });
+    }
+
+    // 업로드된 파일의 URL 배열 생성
+    const fileUrls = req.files.map(file => `/uploads/${file.filename}`);
+
+    res.json({
+      success: true,
+      files: fileUrls,
+      message: `${req.files.length}개의 파일이 업로드되었습니다`
+    });
+  } catch (error) {
+    console.error('이미지 업로드 오류:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 단일 이미지 업로드
+router.post('/single', upload.single('image'), (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ error: '파일이 업로드되지 않았습니다' });
+    }
+
+    const fileUrl = `/uploads/${req.file.filename}`;
+
+    res.json({
+      success: true,
+      file: fileUrl,
+      message: '파일이 업로드되었습니다'
+    });
+  } catch (error) {
+    console.error('이미지 업로드 오류:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;
diff --git a/server/schema.sql b/server/schema.sql
new file mode 100644
index 0000000..465607d
--- /dev/null
+++ b/server/schema.sql
@@ -0,0 +1,66 @@
+-- 여행 계획 테이블
+CREATE TABLE IF NOT EXISTS travel_plans (
+  id SERIAL PRIMARY KEY,
+  start_date DATE NOT NULL,
+  end_date DATE NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 날짜별 일정 테이블
+CREATE TABLE IF NOT EXISTS day_schedules (
+  id SERIAL PRIMARY KEY,
+  travel_plan_id INTEGER REFERENCES travel_plans(id) ON DELETE CASCADE,
+  schedule_date DATE NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 활동 테이블
+CREATE TABLE IF NOT EXISTS activities (
+  id SERIAL PRIMARY KEY,
+  day_schedule_id INTEGER REFERENCES day_schedules(id) ON DELETE CASCADE,
+  time VARCHAR(10) NOT NULL,
+  title VARCHAR(255) NOT NULL,
+  description TEXT,
+  location VARCHAR(255),
+  type VARCHAR(50) NOT NULL,
+  lat DECIMAL(10, 7),
+  lng DECIMAL(10, 7),
+  images TEXT[],
+  links TEXT[],
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 관련 장소 테이블
+CREATE TABLE IF NOT EXISTS related_places (
+  id SERIAL PRIMARY KEY,
+  activity_id INTEGER REFERENCES activities(id) ON DELETE CASCADE,
+  name VARCHAR(255) NOT NULL,
+  description TEXT,
+  address VARCHAR(255),
+  lat DECIMAL(10, 7),
+  lng DECIMAL(10, 7),
+  memo TEXT,
+  will_visit BOOLEAN DEFAULT false,
+  category VARCHAR(50) DEFAULT 'other',
+  images TEXT[],
+  links TEXT[],
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 기본 포인트 테이블
+CREATE TABLE IF NOT EXISTS base_points (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  address VARCHAR(255),
+  type VARCHAR(50) NOT NULL,
+  lat DECIMAL(10, 7) NOT NULL,
+  lng DECIMAL(10, 7) NOT NULL,
+  memo TEXT,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 인덱스 생성
+CREATE INDEX IF NOT EXISTS idx_day_schedules_plan ON day_schedules(travel_plan_id);
+CREATE INDEX IF NOT EXISTS idx_activities_schedule ON activities(day_schedule_id);
+CREATE INDEX IF NOT EXISTS idx_related_places_activity ON related_places(activity_id);
diff --git a/server/schema_v2.sql b/server/schema_v2.sql
new file mode 100644
index 0000000..391e090
--- /dev/null
+++ b/server/schema_v2.sql
@@ -0,0 +1,226 @@
+-- Travel Planner v2.0 Database Schema
+-- 멀티 사용자 및 여행 관리 시스템
+
+-- 사용자 테이블
+CREATE TABLE IF NOT EXISTS users (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  email VARCHAR(255) UNIQUE NOT NULL,
+  password_hash VARCHAR(255) NOT NULL,
+  name VARCHAR(255) NOT NULL,
+  role VARCHAR(20) DEFAULT 'user' CHECK (role IN ('admin', 'user')),
+  is_active BOOLEAN DEFAULT true,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  last_login TIMESTAMP,
+  created_by UUID REFERENCES users(id)
+);
+
+-- 여행 계획 테이블 (확장)
+CREATE TABLE IF NOT EXISTS travel_plans (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  title VARCHAR(255) NOT NULL,
+  description TEXT,
+  
+  -- 목적지 정보
+  destination_country VARCHAR(100) NOT NULL,
+  destination_city VARCHAR(100) NOT NULL,
+  destination_region VARCHAR(100),
+  destination_lat DECIMAL(10, 7),
+  destination_lng DECIMAL(10, 7),
+  
+  -- 날짜
+  start_date DATE NOT NULL,
+  end_date DATE NOT NULL,
+  
+  -- 메타데이터
+  is_public BOOLEAN DEFAULT false,
+  is_template BOOLEAN DEFAULT false,
+  template_category VARCHAR(20) CHECK (template_category IN ('japan', 'korea', 'asia', 'europe', 'america', 'other')),
+  tags TEXT[] DEFAULT '{}',
+  thumbnail VARCHAR(500),
+  status VARCHAR(20) DEFAULT 'draft' CHECK (status IN ('draft', 'active', 'completed', 'cancelled')),
+  
+  -- 타임스탬프
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 날짜별 일정 테이블
+CREATE TABLE IF NOT EXISTS day_schedules (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  travel_plan_id UUID NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  schedule_date DATE NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 활동 테이블 (확장)
+CREATE TABLE IF NOT EXISTS activities (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  day_schedule_id UUID NOT NULL REFERENCES day_schedules(id) ON DELETE CASCADE,
+  time VARCHAR(10) NOT NULL,
+  title VARCHAR(255) NOT NULL,
+  description TEXT,
+  location VARCHAR(255),
+  type VARCHAR(50) NOT NULL CHECK (type IN ('attraction', 'food', 'accommodation', 'transport', 'other')),
+  
+  -- 좌표
+  lat DECIMAL(10, 7),
+  lng DECIMAL(10, 7),
+  
+  -- 미디어
+  images TEXT[] DEFAULT '{}',
+  links JSONB DEFAULT '[]',
+  
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 관련 장소 테이블
+CREATE TABLE IF NOT EXISTS related_places (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  activity_id UUID NOT NULL REFERENCES activities(id) ON DELETE CASCADE,
+  name VARCHAR(255) NOT NULL,
+  description TEXT,
+  address VARCHAR(255),
+  lat DECIMAL(10, 7),
+  lng DECIMAL(10, 7),
+  memo TEXT,
+  will_visit BOOLEAN DEFAULT false,
+  category VARCHAR(50) DEFAULT 'other' CHECK (category IN ('restaurant', 'attraction', 'shopping', 'accommodation', 'other')),
+  images TEXT[] DEFAULT '{}',
+  links JSONB DEFAULT '[]',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 기본 포인트 테이블
+CREATE TABLE IF NOT EXISTS base_points (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+  name VARCHAR(255) NOT NULL,
+  address VARCHAR(255),
+  type VARCHAR(50) NOT NULL CHECK (type IN ('accommodation', 'airport', 'station', 'parking', 'other')),
+  lat DECIMAL(10, 7) NOT NULL,
+  lng DECIMAL(10, 7) NOT NULL,
+  memo TEXT,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 예산 테이블
+CREATE TABLE IF NOT EXISTS budgets (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  travel_plan_id UUID NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  total_amount DECIMAL(12, 2) DEFAULT 0,
+  accommodation DECIMAL(12, 2) DEFAULT 0,
+  food DECIMAL(12, 2) DEFAULT 0,
+  transportation DECIMAL(12, 2) DEFAULT 0,
+  shopping DECIMAL(12, 2) DEFAULT 0,
+  activities DECIMAL(12, 2) DEFAULT 0,
+  currency VARCHAR(3) DEFAULT 'KRW',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 체크리스트 테이블
+CREATE TABLE IF NOT EXISTS checklist_items (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  travel_plan_id UUID NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  text VARCHAR(500) NOT NULL,
+  checked BOOLEAN DEFAULT false,
+  category VARCHAR(50) DEFAULT 'other' CHECK (category IN ('preparation', 'shopping', 'visit', 'other')),
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 공유 링크 테이블
+CREATE TABLE IF NOT EXISTS share_links (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  trip_id UUID NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  created_by UUID NOT NULL REFERENCES users(id),
+  share_code VARCHAR(8) UNIQUE NOT NULL,
+  expires_at TIMESTAMP,
+  is_active BOOLEAN DEFAULT true,
+  access_count INTEGER DEFAULT 0,
+  max_access_count INTEGER,
+  
+  -- 권한
+  can_view BOOLEAN DEFAULT true,
+  can_edit BOOLEAN DEFAULT false,
+  can_comment BOOLEAN DEFAULT false,
+  
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  last_accessed TIMESTAMP
+);
+
+-- 댓글 테이블
+CREATE TABLE IF NOT EXISTS trip_comments (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  trip_id UUID NOT NULL REFERENCES travel_plans(id) ON DELETE CASCADE,
+  user_id UUID NOT NULL REFERENCES users(id),
+  content TEXT NOT NULL,
+  is_edited BOOLEAN DEFAULT false,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 시스템 설정 테이블
+CREATE TABLE IF NOT EXISTS system_settings (
+  key VARCHAR(100) PRIMARY KEY,
+  value TEXT,
+  description TEXT,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+-- 인덱스 생성
+CREATE INDEX IF NOT EXISTS idx_users_email ON users(email);
+CREATE INDEX IF NOT EXISTS idx_users_role ON users(role);
+CREATE INDEX IF NOT EXISTS idx_travel_plans_user ON travel_plans(user_id);
+CREATE INDEX IF NOT EXISTS idx_travel_plans_status ON travel_plans(status);
+CREATE INDEX IF NOT EXISTS idx_travel_plans_category ON travel_plans(template_category);
+CREATE INDEX IF NOT EXISTS idx_travel_plans_public ON travel_plans(is_public);
+CREATE INDEX IF NOT EXISTS idx_day_schedules_plan ON day_schedules(travel_plan_id);
+CREATE INDEX IF NOT EXISTS idx_activities_schedule ON activities(day_schedule_id);
+CREATE INDEX IF NOT EXISTS idx_related_places_activity ON related_places(activity_id);
+CREATE INDEX IF NOT EXISTS idx_base_points_user ON base_points(user_id);
+CREATE INDEX IF NOT EXISTS idx_budgets_plan ON budgets(travel_plan_id);
+CREATE INDEX IF NOT EXISTS idx_checklist_plan ON checklist_items(travel_plan_id);
+CREATE INDEX IF NOT EXISTS idx_share_links_code ON share_links(share_code);
+CREATE INDEX IF NOT EXISTS idx_share_links_trip ON share_links(trip_id);
+CREATE INDEX IF NOT EXISTS idx_comments_trip ON trip_comments(trip_id);
+
+-- 초기 시스템 설정 데이터
+INSERT INTO system_settings (key, value, description) VALUES
+  ('app_version', '2.0.0', '애플리케이션 버전'),
+  ('setup_completed', 'false', '초기 설정 완료 여부'),
+  ('jwt_secret_set', 'false', 'JWT 시크릿 설정 여부'),
+  ('google_maps_configured', 'false', 'Google Maps API 설정 여부'),
+  ('email_configured', 'false', '이메일 설정 여부')
+ON CONFLICT (key) DO NOTHING;
+
+-- 업데이트 트리거 함수
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.updated_at = CURRENT_TIMESTAMP;
+  RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- 업데이트 트리거 적용
+DROP TRIGGER IF EXISTS update_users_updated_at ON users;
+CREATE TRIGGER update_users_updated_at BEFORE UPDATE ON users FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_travel_plans_updated_at ON travel_plans;
+CREATE TRIGGER update_travel_plans_updated_at BEFORE UPDATE ON travel_plans FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_budgets_updated_at ON budgets;
+CREATE TRIGGER update_budgets_updated_at BEFORE UPDATE ON budgets FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_checklist_updated_at ON checklist_items;
+CREATE TRIGGER update_checklist_updated_at BEFORE UPDATE ON checklist_items FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_comments_updated_at ON trip_comments;
+CREATE TRIGGER update_comments_updated_at BEFORE UPDATE ON trip_comments FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
+
+DROP TRIGGER IF EXISTS update_settings_updated_at ON system_settings;
+CREATE TRIGGER update_settings_updated_at BEFORE UPDATE ON system_settings FOR EACH ROW EXECUTE FUNCTION update_updated_at_column();
diff --git a/server/server.js b/server/server.js
new file mode 100644
index 0000000..db55611
--- /dev/null
+++ b/server/server.js
@@ -0,0 +1,66 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const { initializeDatabase } = require('./db');
+const { runMigrations } = require('./migrate');
+const travelPlanRoutes = require('./routes/travelPlans');
+const basePointsRoutes = require('./routes/basePoints');
+const uploadsRoutes = require('./routes/uploads');
+const { router: authRoutes } = require('./routes/auth');
+const setupRoutes = require('./routes/setup');
+
+const app = express();
+const PORT = process.env.PORT || 3000;
+
+// 미들웨어
+app.use(cors());
+app.use(express.json());
+
+// 정적 파일 제공 (업로드된 이미지)
+app.use('/uploads', express.static(path.join(__dirname, 'uploads')));
+
+// 로그 미들웨어
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.path}`);
+  next();
+});
+
+// 라우트
+app.use('/api/auth', authRoutes);
+app.use('/api/setup', setupRoutes);
+app.use('/api/travel-plans', travelPlanRoutes);
+app.use('/api/base-points', basePointsRoutes);
+app.use('/api/uploads', uploadsRoutes);
+
+// 헬스 체크
+app.get('/health', (req, res) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+
+// 에러 핸들러
+app.use((err, req, res, next) => {
+  console.error('Error:', err);
+  res.status(500).json({ error: err.message });
+});
+
+// 서버 시작
+async function startServer() {
+  try {
+    // 데이터베이스 초기화 (기존 스키마)
+    await initializeDatabase();
+    
+    // 마이그레이션 실행 (새로운 기능 추가)
+    await runMigrations();
+
+    app.listen(PORT, '0.0.0.0', () => {
+      console.log(`🚀 Server running on port ${PORT}`);
+      console.log(`📊 API available at http://localhost:${PORT}`);
+      console.log(`🗄️ Database: Using existing kumamoto_map database`);
+    });
+  } catch (error) {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+  }
+}
+
+startServer();
diff --git a/server/uploads/images-1762666367693-99912431.webp b/server/uploads/images-1762666367693-99912431.webp
new file mode 100644
index 0000000000000000000000000000000000000000..fde02f1231c789110c557c89385409433345cbd0
GIT binary patch
literal 31956
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

literal 0
HcmV?d00001

diff --git a/server/uploads/images-1762666492636-867051147.jpg b/server/uploads/images-1762666492636-867051147.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..52db59fd83b9b275cd1b9bd5f207a160735f4585
GIT binary patch
literal 63403
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
K;)*D%5&zl$I(H@j

literal 0
HcmV?d00001

diff --git a/src/App.tsx b/src/App.tsx
index 8db415d..4ccdb0e 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,144 +1,252 @@
-import { useState } from 'react'
-import Header from './components/Header'
-import Timeline from './components/Timeline'
-import Attractions, { attractions } from './components/Attractions'
-import Map from './components/Map'
-import Budget from './components/Budget'
-import Checklist from './components/Checklist'
-import { TravelPlan } from './types'
+import { BrowserRouter, Routes, Route, Navigate, useNavigate } from 'react-router-dom'
+import { useEffect, useState } from 'react'
+import PlanPage from './pages/PlanPage'
+import TripPage from './pages/TripPage'
+import InitialSetup from './components/InitialSetup'
+import AuthForm from './components/AuthForm'
+import AdminDashboard from './components/AdminDashboard'
+import UserDashboard from './components/UserDashboard'
+import SharedTripViewer from './components/SharedTripViewer'
+import DebugInfo from './components/DebugInfo'
+import { tripManagerService } from './services/tripManager'
+import { defaultTravelPlan } from './constants/defaultData'
+import { initialSetupService, SetupUtils } from './services/initialSetup'
+import { userAuthService } from './services/userAuth'
 
-function App() {
-  const [travelPlan, setTravelPlan] = useState<TravelPlan>({
-    startDate: new Date('2025-02-17'),
-    endDate: new Date('2025-02-20'),
-    schedule: [
-      {
-        date: new Date('2025-02-18'),
-        activities: [
-          {
-            id: '1',
-            time: '09:00',
-            title: '렌트카 픽업',
-            description: '렌트카로 이동',
-            type: 'transport',
-          },
-          {
-            id: '2',
-            time: '10:00',
-            title: '기쿠치협곡',
-            description: '렌트카로 이동',
-            location: '기쿠치시',
-            type: 'attraction',
-          },
-          {
-            id: '3',
-            time: '12:00',
-            title: '쿠사센리',
-            description: '렌트카로 이동',
-            location: '아소시',
-            type: 'attraction',
-          },
-          {
-            id: '4',
-            time: '14:00',
-            title: '아소산',
-            description: '렌트카로 이동',
-            location: '아소시',
-            type: 'attraction',
-          },
-          {
-            id: '5',
-            time: '16:00',
-            title: '사라카와수원',
-            description: '렌트카로 이동',
-            location: '구마모토시',
-            type: 'attraction',
-          },
-        ],
-      },
-      {
-        date: new Date('2025-02-19'),
-        activities: [
-          {
-            id: '6',
-            time: '09:00',
-            title: '구마모토성',
-            description: '대중교통으로 이동',
-            location: '구마모토시 주오구',
-            type: 'attraction',
-          },
-          {
-            id: '7',
-            time: '11:30',
-            title: '사쿠라노바바',
-            description: '대중교통으로 이동',
-            location: '구마모토시',
-            type: 'attraction',
-          },
-          {
-            id: '8',
-            time: '14:00',
-            title: '스이젠지조주엔',
-            description: '대중교통으로 이동',
-            location: '구마모토시 주오구',
-            type: 'attraction',
-          },
-          {
-            id: '9',
-            time: '16:00',
-            title: '시모토리아케이드',
-            description: '대중교통으로 이동',
-            location: '구마모토시',
-            type: 'attraction',
-          },
-        ],
-      },
-    ],
-    budget: {
-      total: 0,
-      accommodation: 0,
-      food: 0,
-      transportation: 0,
-      shopping: 0,
-      activities: 0,
-    },
-    checklist: [],
-  })
+// 메인 대시보드 컴포넌트
+function Home() {
+  return (
+    <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+      <UserDashboard />
+    </div>
+  )
+}
+
+// 레거시 라우트 처리 컴포넌트
+function LegacyTripRedirect() {
+  const navigate = useNavigate()
+  const [isCreating, setIsCreating] = useState(false)
+
+  useEffect(() => {
+    const createLegacyTrip = async () => {
+      setIsCreating(true)
+      
+      try {
+        // 기존 구마모토 여행이 있는지 확인
+        const userTrips = await tripManagerService.getUserTrips({ search: '구마모토' })
+        
+        let legacyTrip = userTrips.trips.find(trip => 
+          trip.title.includes('구마모토') || trip.destination.city === '구마모토'
+        )
+
+        // 없으면 새로 생성
+        if (!legacyTrip) {
+          const result = await tripManagerService.createTrip({
+            title: defaultTravelPlan.title,
+            description: defaultTravelPlan.description,
+            destination: defaultTravelPlan.destination,
+            startDate: defaultTravelPlan.startDate,
+            endDate: defaultTravelPlan.endDate,
+            template_category: defaultTravelPlan.template_category,
+            tags: defaultTravelPlan.tags,
+            is_public: defaultTravelPlan.is_public
+          })
+
+          if (result.success && result.trip) {
+            // 기본 일정도 추가
+            await tripManagerService.updateTrip(result.trip.id, {
+              ...result.trip,
+              schedule: defaultTravelPlan.schedule,
+              budget: defaultTravelPlan.budget,
+              checklist: defaultTravelPlan.checklist
+            })
+            legacyTrip = result.trip
+          }
+        }
+
+        // 여행 모드로 리다이렉트
+        if (legacyTrip) {
+          const currentPath = window.location.pathname
+          if (currentPath.includes('/plan')) {
+            navigate(`/plan/${legacyTrip.id}`)
+          } else {
+            navigate(`/trip/${legacyTrip.id}`)
+          }
+        } else {
+          // 생성 실패시 메인으로
+          navigate('/')
+        }
+      } catch (error) {
+        console.error('Failed to create legacy trip:', error)
+        navigate('/')
+      } finally {
+        setIsCreating(false)
+      }
+    }
+
+    createLegacyTrip()
+  }, [navigate])
 
   return (
-    <div className="min-h-screen bg-kumamoto-light">
-      <Header />
-      <main className="container mx-auto px-4 py-8 max-w-7xl">
-        <div className="mb-8 relative">
-          <div className="relative rounded-lg overflow-hidden mb-4 h-64">
-            <img
-              src="https://images.unsplash.com/photo-1501594907352-04cda38ebc29?w=1920&q=80"
-              alt="구마모토 풍경"
-              className="w-full h-full object-cover"
-            />
-            <div className="absolute inset-0 bg-gradient-to-t from-black/60 to-transparent" />
-            <div className="absolute bottom-0 left-0 right-0 p-6 text-white">
-              <h1 className="text-4xl font-bold mb-2">구마모토 여행 계획</h1>
-              <p className="text-lg opacity-90">
-                2025년 2월 17일 ~ 2월 20일 (4일간)
-              </p>
+    <div className="min-h-screen bg-kumamoto-light flex items-center justify-center">
+      <div className="text-center">
+        <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-kumamoto-primary mx-auto mb-4"></div>
+        <div className="text-lg text-gray-600 mb-2">
+          {isCreating ? '구마모토 여행 계획을 준비하는 중...' : '페이지를 로딩 중...'}
+        </div>
+        <div className="text-sm text-gray-500">
+          기존 여행 계획을 새로운 형태로 변환하고 있습니다
+        </div>
+      </div>
+    </div>
+  )
+}
+
+function App() {
+  const [isSetupRequired, setIsSetupRequired] = useState<boolean | null>(null)
+  const [isAuthenticated, setIsAuthenticated] = useState(false)
+  const [isLoading, setIsLoading] = useState(true)
+  
+  // 디버그 모드 (URL에 ?debug=true가 있으면 활성화)
+  const showDebug = new URLSearchParams(window.location.search).get('debug') === 'true'
+
+  useEffect(() => {
+    checkAppStatus()
+  }, [])
+
+  const checkAppStatus = async () => {
+    try {
+      // 1. 초기 설정 필요 여부 확인
+      const setupRequired = await SetupUtils.isSetupRequired()
+      setIsSetupRequired(setupRequired)
+
+      if (!setupRequired) {
+        // 2. 사용자 인증 상태 확인
+        const authenticated = userAuthService.isAuthenticated()
+        setIsAuthenticated(authenticated)
+      }
+    } catch (error) {
+      console.error('App status check failed:', error)
+      setIsSetupRequired(true) // 오류 시 초기 설정으로 안내
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleSetupComplete = () => {
+    setIsSetupRequired(false)
+    checkAppStatus() // 상태 재확인
+  }
+
+  const handleAuthSuccess = () => {
+    setIsAuthenticated(true)
+  }
+
+  const handleLogout = async () => {
+    await userAuthService.logout()
+    setIsAuthenticated(false)
+  }
+
+  // 로딩 중
+  // 디버그 모드
+  if (showDebug) {
+    return <DebugInfo />
+  }
+
+  if (isLoading) {
+    return (
+      <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 flex items-center justify-center">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
+          <div className="text-lg font-medium text-gray-800">시스템 초기화 중...</div>
+        </div>
+      </div>
+    )
+  }
+
+  // 초기 설정 필요
+  if (isSetupRequired) {
+    return <InitialSetup onSetupComplete={handleSetupComplete} />
+  }
+
+  // 로그인 필요
+  if (!isAuthenticated) {
+    return (
+      <div className="min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 flex items-center justify-center">
+        <AuthForm onSuccess={handleAuthSuccess} />
+      </div>
+    )
+  }
+
+  // 인증된 사용자 - 메인 앱
+  return (
+    <BrowserRouter>
+      <div className="min-h-screen bg-kumamoto-light">
+        {/* 상단 네비게이션 */}
+        <nav className="bg-white shadow-sm border-b border-gray-200">
+          <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+            <div className="flex justify-between items-center h-16">
+              <div className="flex items-center">
+                <h1 className="text-xl font-bold text-gray-800">
+                  🗺️ Travel Planner
+                </h1>
+              </div>
+              
+              <div className="flex items-center gap-4">
+                <span className="text-sm text-gray-600">
+                  {userAuthService.getCurrentUser()?.name}님
+                  {userAuthService.isAdmin() && (
+                    <span className="ml-2 px-2 py-1 bg-purple-100 text-purple-800 text-xs rounded">
+                      관리자
+                    </span>
+                  )}
+                </span>
+                
+                {userAuthService.isAdmin() && (
+                  <a
+                    href="/admin"
+                    className="text-sm text-purple-600 hover:text-purple-800"
+                  >
+                    관리자 페이지
+                  </a>
+                )}
+                
+                <button
+                  onClick={handleLogout}
+                  className="text-sm text-gray-600 hover:text-gray-800"
+                >
+                  로그아웃
+                </button>
+              </div>
             </div>
           </div>
-        </div>
+        </nav>
 
-        <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
-          <div className="lg:col-span-2 space-y-6">
-            <Map attractions={attractions} />
-            <Timeline travelPlan={travelPlan} setTravelPlan={setTravelPlan} />
-            <Attractions />
-          </div>
-          <div className="space-y-6">
-            <Budget travelPlan={travelPlan} setTravelPlan={setTravelPlan} />
-            <Checklist travelPlan={travelPlan} setTravelPlan={setTravelPlan} />
-          </div>
-        </div>
-      </main>
-    </div>
+        {/* 메인 콘텐츠 */}
+        <Routes>
+          <Route path="/" element={<Home />} />
+          <Route path="/plan/:tripId" element={<PlanPage />} />
+          <Route path="/trip/:tripId" element={<TripPage />} />
+          <Route path="/shared/:shareCode" element={<SharedTripViewer />} />
+          <Route 
+            path="/admin" 
+            element={
+              userAuthService.isAdmin() ? (
+                <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+                  <AdminDashboard />
+                </div>
+              ) : (
+                <Navigate to="/" replace />
+              )
+            } 
+          />
+          {/* 레거시 라우트 (기존 구마모토 여행) - 테스트용 자동 생성 */}
+          <Route path="/plan" element={<LegacyTripRedirect />} />
+          <Route path="/trip" element={<LegacyTripRedirect />} />
+          <Route path="*" element={<Navigate to="/" replace />} />
+        </Routes>
+      </div>
+    </BrowserRouter>
   )
 }
 
diff --git a/src/components/ActivityEditor.tsx b/src/components/ActivityEditor.tsx
new file mode 100644
index 0000000..1278590
--- /dev/null
+++ b/src/components/ActivityEditor.tsx
@@ -0,0 +1,208 @@
+import { useState } from 'react'
+import { Activity, RelatedPlace } from '../types'
+import RelatedPlacesManager from './RelatedPlacesManager'
+import LocationSelector from './forms/LocationSelector'
+import ImageUploadField from './forms/ImageUploadField'
+import LinkManagement from './forms/LinkManagement'
+
+interface ActivityEditorProps {
+  activity: Activity
+  onUpdate: (activity: Activity) => void
+  onClose: () => void
+}
+
+const ActivityEditor = ({ activity, onUpdate, onClose }: ActivityEditorProps) => {
+  const [formData, setFormData] = useState<Activity>(activity)
+  const [showRelatedPlacesManager, setShowRelatedPlacesManager] = useState(false)
+
+  const updateRelatedPlaces = (relatedPlaces: RelatedPlace[]) => {
+    setFormData({
+      ...formData,
+      relatedPlaces
+    })
+  }
+
+  const handleSave = () => {
+    if (!formData.title || !formData.time) {
+      alert('제목과 시간은 필수입니다.')
+      return
+    }
+
+    // 좌표가 0,0이면 제거
+    const updatedActivity = {
+      ...formData,
+      coordinates: formData.coordinates &&
+                   formData.coordinates.lat !== 0 &&
+                   formData.coordinates.lng !== 0
+        ? formData.coordinates
+        : undefined
+    }
+
+    onUpdate(updatedActivity)
+    onClose()
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
+      <div className="bg-white rounded-lg shadow-xl max-w-2xl w-full max-h-[90vh] overflow-y-auto">
+        <div className="sticky top-0 bg-white border-b border-gray-200 p-4 flex items-center justify-between">
+          <h3 className="text-xl font-bold text-gray-800">일정 편집</h3>
+          <button
+            onClick={onClose}
+            className="text-gray-500 hover:text-gray-700 text-2xl leading-none"
+          >
+            ×
+          </button>
+        </div>
+
+        <div className="p-6 space-y-4">
+          {/* 시간 */}
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              시간 <span className="text-red-500">*</span>
+            </label>
+            <input
+              type="time"
+              value={formData.time}
+              onChange={(e) => setFormData({ ...formData, time: e.target.value })}
+              className="w-full px-3 py-2 border rounded"
+            />
+          </div>
+
+          {/* 제목 */}
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              제목 <span className="text-red-500">*</span>
+            </label>
+            <input
+              type="text"
+              value={formData.title}
+              onChange={(e) => setFormData({ ...formData, title: e.target.value })}
+              className="w-full px-3 py-2 border rounded"
+              placeholder="일정 제목"
+            />
+          </div>
+
+          {/* 설명 */}
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">설명</label>
+            <textarea
+              value={formData.description || ''}
+              onChange={(e) => setFormData({ ...formData, description: e.target.value })}
+              className="w-full px-3 py-2 border rounded"
+              placeholder="설명 (선택)"
+              rows={3}
+            />
+          </div>
+
+          {/* 장소 및 위치 정보 - LocationSelector 사용 */}
+          <div className="border border-gray-300 rounded p-4 bg-gray-50">
+            <LocationSelector
+              location={formData.location}
+              coordinates={formData.coordinates}
+              onLocationChange={(location) => setFormData({ ...formData, location })}
+              onCoordinatesChange={(coordinates) => setFormData({ ...formData, coordinates: coordinates || undefined })}
+            />
+          </div>
+
+          {/* 분류 */}
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">분류</label>
+            <select
+              value={formData.type}
+              onChange={(e) => setFormData({ ...formData, type: e.target.value as Activity['type'] })}
+              className="w-full px-3 py-2 border rounded"
+            >
+              <option value="attraction">관광지</option>
+              <option value="food">식사</option>
+              <option value="accommodation">숙소</option>
+              <option value="transport">교통</option>
+              <option value="other">기타</option>
+            </select>
+          </div>
+
+          {/* 주변 관광지 관리 */}
+          <div className="border-t pt-4">
+            <div className="flex items-center justify-between mb-2">
+              <label className="text-sm font-medium text-gray-700">
+                주변 관광지 / 세부 관광지
+              </label>
+              <span className="text-xs text-gray-500">
+                {formData.relatedPlaces?.length || 0}개 등록됨
+              </span>
+            </div>
+            <button
+              type="button"
+              onClick={() => setShowRelatedPlacesManager(true)}
+              className="w-full px-4 py-3 bg-gradient-to-r from-blue-50 to-indigo-50 border-2 border-blue-200 text-blue-700 rounded-lg hover:from-blue-100 hover:to-indigo-100 transition-all flex items-center justify-between"
+            >
+              <div className="flex items-center gap-2">
+                <span className="text-lg">🏞️</span>
+                <div className="text-left">
+                  <div className="font-medium">주변 관광지 관리</div>
+                  <div className="text-xs text-blue-600">
+                    세부 관광지 추가/수정 및 가볼 곳 체크
+                  </div>
+                </div>
+              </div>
+              <span className="text-blue-500">→</span>
+            </button>
+            {formData.relatedPlaces && formData.relatedPlaces.length > 0 && (
+              <div className="mt-2 text-xs text-gray-600">
+                {formData.relatedPlaces.filter(p => p.willVisit).length}개 가볼 곳으로 선택됨
+                {formData.relatedPlaces.filter(p => p.willVisit).length > 0 && (
+                  <span className="text-green-600 ml-1">
+                    (Trip 페이지에 표시됨)
+                  </span>
+                )}
+              </div>
+            )}
+          </div>
+
+          {/* 이미지 업로드 - ImageUploadField 사용 */}
+          <div className="border-t pt-4">
+            <ImageUploadField
+              images={formData.images || []}
+              onChange={(images) => setFormData({ ...formData, images })}
+            />
+          </div>
+
+          {/* 링크 추가 - LinkManagement 사용 */}
+          <div className="border-t pt-4">
+            <LinkManagement
+              links={formData.links || []}
+              onChange={(links) => setFormData({ ...formData, links })}
+            />
+          </div>
+        </div>
+
+        {/* 버튼 */}
+        <div className="sticky bottom-0 bg-gray-50 border-t border-gray-200 p-4 flex gap-2">
+          <button
+            onClick={onClose}
+            className="flex-1 px-4 py-2 bg-gray-300 text-gray-700 rounded hover:bg-gray-400"
+          >
+            취소
+          </button>
+          <button
+            onClick={handleSave}
+            className="flex-1 px-4 py-2 bg-kumamoto-blue text-white rounded hover:bg-opacity-90"
+          >
+            저장
+          </button>
+        </div>
+      </div>
+
+      {/* 주변 관광지 관리 모달 */}
+      {showRelatedPlacesManager && (
+        <RelatedPlacesManager
+          activity={formData}
+          onUpdate={(_, relatedPlaces) => updateRelatedPlaces(relatedPlaces)}
+          onClose={() => setShowRelatedPlacesManager(false)}
+        />
+      )}
+    </div>
+  )
+}
+
+export default ActivityEditor
diff --git a/src/components/AdminDashboard.tsx b/src/components/AdminDashboard.tsx
new file mode 100644
index 0000000..070a281
--- /dev/null
+++ b/src/components/AdminDashboard.tsx
@@ -0,0 +1,510 @@
+import { useState, useEffect } from 'react'
+import { userAuthService, User } from '../services/userAuth'
+
+interface AdminDashboardProps {
+  className?: string
+}
+
+const AdminDashboard = ({ className = '' }: AdminDashboardProps) => {
+  const [users, setUsers] = useState<User[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [showCreateForm, setShowCreateForm] = useState(false)
+  const [selectedUser, setSelectedUser] = useState<User | null>(null)
+  const [stats, setStats] = useState({
+    totalUsers: 0,
+    activeUsers: 0,
+    adminUsers: 0,
+    recentLogins: 0
+  })
+
+  useEffect(() => {
+    loadUsers()
+  }, [])
+
+  const loadUsers = async () => {
+    try {
+      setIsLoading(true)
+      const allUsers = await userAuthService.getAllUsers()
+      setUsers(allUsers)
+      calculateStats(allUsers)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '사용자 목록을 불러올 수 없습니다')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const calculateStats = (userList: User[]) => {
+    const now = new Date()
+    const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000)
+
+    setStats({
+      totalUsers: userList.length,
+      activeUsers: userList.filter(u => u.is_active).length,
+      adminUsers: userList.filter(u => u.role === 'admin').length,
+      recentLogins: userList.filter(u => 
+        u.last_login && new Date(u.last_login) > oneDayAgo
+      ).length
+    })
+  }
+
+  const handleToggleUserStatus = async (userId: string) => {
+    try {
+      const result = await userAuthService.toggleUserStatus(userId)
+      if (result.success) {
+        await loadUsers()
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('사용자 상태 변경 중 오류가 발생했습니다')
+    }
+  }
+
+  const handleDeleteUser = async (userId: string, userName: string) => {
+    if (!confirm(`"${userName}" 사용자를 정말 삭제하시겠습니까?\n\n⚠️ 이 작업은 되돌릴 수 없습니다.`)) {
+      return
+    }
+
+    try {
+      const result = await userAuthService.deleteUser(userId)
+      if (result.success) {
+        await loadUsers()
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('사용자 삭제 중 오류가 발생했습니다')
+    }
+  }
+
+  const formatDate = (dateString?: string) => {
+    if (!dateString) return '-'
+    return new Date(dateString).toLocaleDateString('ko-KR', {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  }
+
+  const getRoleDisplay = (role: string) => {
+    return role === 'admin' ? '👨‍💼 관리자' : '👤 사용자'
+  }
+
+  const getStatusDisplay = (isActive: boolean) => {
+    return isActive ? '✅ 활성' : '❌ 비활성'
+  }
+
+  if (isLoading) {
+    return (
+      <div className={`bg-white rounded-lg shadow-md p-6 ${className}`}>
+        <div className="flex items-center justify-center py-12">
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mr-3"></div>
+          <span>사용자 목록을 불러오는 중...</span>
+        </div>
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <div className={`bg-white rounded-lg shadow-md p-6 ${className}`}>
+        <div className="text-center py-12">
+          <div className="text-red-500 text-4xl mb-4">⚠️</div>
+          <div className="text-red-700">{error}</div>
+          <button
+            onClick={loadUsers}
+            className="mt-4 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+          >
+            다시 시도
+          </button>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className={`bg-white rounded-lg shadow-md ${className}`}>
+      {/* 헤더 */}
+      <div className="p-6 border-b border-gray-200">
+        <div className="flex items-center justify-between">
+          <h2 className="text-2xl font-bold text-gray-800">👨‍💼 관리자 대시보드</h2>
+          <button
+            onClick={() => setShowCreateForm(true)}
+            className="px-4 py-2 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+          >
+            ➕ 사용자 추가
+          </button>
+        </div>
+      </div>
+
+      {/* 통계 카드 */}
+      <div className="p-6 border-b border-gray-200">
+        <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+          <div className="bg-blue-50 p-4 rounded-lg border border-blue-200">
+            <div className="text-2xl font-bold text-blue-800">{stats.totalUsers}</div>
+            <div className="text-sm text-blue-600">전체 사용자</div>
+          </div>
+          <div className="bg-green-50 p-4 rounded-lg border border-green-200">
+            <div className="text-2xl font-bold text-green-800">{stats.activeUsers}</div>
+            <div className="text-sm text-green-600">활성 사용자</div>
+          </div>
+          <div className="bg-purple-50 p-4 rounded-lg border border-purple-200">
+            <div className="text-2xl font-bold text-purple-800">{stats.adminUsers}</div>
+            <div className="text-sm text-purple-600">관리자</div>
+          </div>
+          <div className="bg-orange-50 p-4 rounded-lg border border-orange-200">
+            <div className="text-2xl font-bold text-orange-800">{stats.recentLogins}</div>
+            <div className="text-sm text-orange-600">24시간 내 로그인</div>
+          </div>
+        </div>
+      </div>
+
+      {/* 사용자 목록 */}
+      <div className="p-6">
+        <h3 className="text-lg font-semibold text-gray-800 mb-4">사용자 목록</h3>
+        
+        {users.length === 0 ? (
+          <div className="text-center py-12 text-gray-500">
+            <div className="text-4xl mb-4">👥</div>
+            <div>등록된 사용자가 없습니다</div>
+          </div>
+        ) : (
+          <div className="overflow-x-auto">
+            <table className="w-full border-collapse">
+              <thead>
+                <tr className="border-b border-gray-200">
+                  <th className="text-left py-3 px-4 font-medium text-gray-700">사용자</th>
+                  <th className="text-left py-3 px-4 font-medium text-gray-700">권한</th>
+                  <th className="text-left py-3 px-4 font-medium text-gray-700">상태</th>
+                  <th className="text-left py-3 px-4 font-medium text-gray-700">가입일</th>
+                  <th className="text-left py-3 px-4 font-medium text-gray-700">마지막 로그인</th>
+                  <th className="text-left py-3 px-4 font-medium text-gray-700">작업</th>
+                </tr>
+              </thead>
+              <tbody>
+                {users.map((user) => (
+                  <tr key={user.id} className="border-b border-gray-100 hover:bg-gray-50">
+                    <td className="py-3 px-4">
+                      <div className="flex items-center gap-3">
+                        {user.avatar ? (
+                          <img src={user.avatar} alt={user.name} className="w-8 h-8 rounded-full" />
+                        ) : (
+                          <div className="w-8 h-8 bg-gray-300 rounded-full flex items-center justify-center text-sm">
+                            {user.name.charAt(0).toUpperCase()}
+                          </div>
+                        )}
+                        <div>
+                          <div className="font-medium text-gray-800">{user.name}</div>
+                          <div className="text-sm text-gray-600">{user.email}</div>
+                        </div>
+                      </div>
+                    </td>
+                    <td className="py-3 px-4">
+                      <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${
+                        user.role === 'admin' 
+                          ? 'bg-purple-100 text-purple-800' 
+                          : 'bg-gray-100 text-gray-800'
+                      }`}>
+                        {getRoleDisplay(user.role)}
+                      </span>
+                    </td>
+                    <td className="py-3 px-4">
+                      <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${
+                        user.is_active 
+                          ? 'bg-green-100 text-green-800' 
+                          : 'bg-red-100 text-red-800'
+                      }`}>
+                        {getStatusDisplay(user.is_active)}
+                      </span>
+                    </td>
+                    <td className="py-3 px-4 text-sm text-gray-600">
+                      {formatDate(user.created_at)}
+                    </td>
+                    <td className="py-3 px-4 text-sm text-gray-600">
+                      {formatDate(user.last_login)}
+                    </td>
+                    <td className="py-3 px-4">
+                      <div className="flex items-center gap-2">
+                        <button
+                          onClick={() => handleToggleUserStatus(user.id)}
+                          className={`px-2 py-1 text-xs rounded ${
+                            user.is_active
+                              ? 'bg-red-100 text-red-700 hover:bg-red-200'
+                              : 'bg-green-100 text-green-700 hover:bg-green-200'
+                          }`}
+                          title={user.is_active ? '비활성화' : '활성화'}
+                        >
+                          {user.is_active ? '🔒' : '🔓'}
+                        </button>
+                        <button
+                          onClick={() => setSelectedUser(user)}
+                          className="px-2 py-1 text-xs bg-blue-100 text-blue-700 rounded hover:bg-blue-200"
+                          title="수정"
+                        >
+                          ✏️
+                        </button>
+                        {user.role !== 'admin' && (
+                          <button
+                            onClick={() => handleDeleteUser(user.id, user.name)}
+                            className="px-2 py-1 text-xs bg-red-100 text-red-700 rounded hover:bg-red-200"
+                            title="삭제"
+                          >
+                            🗑️
+                          </button>
+                        )}
+                      </div>
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        )}
+      </div>
+
+      {/* 사용자 생성 모달 */}
+      {showCreateForm && (
+        <CreateUserModal
+          onClose={() => setShowCreateForm(false)}
+          onSuccess={() => {
+            setShowCreateForm(false)
+            loadUsers()
+          }}
+        />
+      )}
+
+      {/* 사용자 수정 모달 */}
+      {selectedUser && (
+        <EditUserModal
+          user={selectedUser}
+          onClose={() => setSelectedUser(null)}
+          onSuccess={() => {
+            setSelectedUser(null)
+            loadUsers()
+          }}
+        />
+      )}
+    </div>
+  )
+}
+
+// 사용자 생성 모달
+const CreateUserModal = ({ onClose, onSuccess }: { onClose: () => void; onSuccess: () => void }) => {
+  const [formData, setFormData] = useState({
+    email: '',
+    password: '',
+    name: '',
+    role: 'user' as 'admin' | 'user'
+  })
+  const [isSubmitting, setIsSubmitting] = useState(false)
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+
+    try {
+      const result = await userAuthService.createUser(formData)
+      if (result.success) {
+        alert(result.message)
+        onSuccess()
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('사용자 생성 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+      <div className="bg-white rounded-lg p-6 w-full max-w-md">
+        <h3 className="text-lg font-semibold mb-4">새 사용자 추가</h3>
+        
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">이메일</label>
+            <input
+              type="email"
+              value={formData.email}
+              onChange={(e) => setFormData({ ...formData, email: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              required
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">이름</label>
+            <input
+              type="text"
+              value={formData.name}
+              onChange={(e) => setFormData({ ...formData, name: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              required
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">비밀번호</label>
+            <input
+              type="password"
+              value={formData.password}
+              onChange={(e) => setFormData({ ...formData, password: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              required
+              minLength={6}
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">권한</label>
+            <select
+              value={formData.role}
+              onChange={(e) => setFormData({ ...formData, role: e.target.value as 'admin' | 'user' })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            >
+              <option value="user">👤 사용자</option>
+              <option value="admin">👨‍💼 관리자</option>
+            </select>
+          </div>
+          
+          <div className="flex gap-2 pt-4">
+            <button
+              type="button"
+              onClick={onClose}
+              className="flex-1 px-4 py-2 border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+            >
+              취소
+            </button>
+            <button
+              type="submit"
+              disabled={isSubmitting}
+              className="flex-1 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50"
+            >
+              {isSubmitting ? '생성 중...' : '생성'}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  )
+}
+
+// 사용자 수정 모달
+const EditUserModal = ({ 
+  user, 
+  onClose, 
+  onSuccess 
+}: { 
+  user: User; 
+  onClose: () => void; 
+  onSuccess: () => void 
+}) => {
+  const [formData, setFormData] = useState({
+    name: user.name,
+    role: user.role,
+    is_active: user.is_active
+  })
+  const [isSubmitting, setIsSubmitting] = useState(false)
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+
+    try {
+      const result = await userAuthService.updateUser(user.id, formData)
+      if (result.success) {
+        alert(result.message)
+        onSuccess()
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('사용자 정보 수정 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+      <div className="bg-white rounded-lg p-6 w-full max-w-md">
+        <h3 className="text-lg font-semibold mb-4">사용자 정보 수정</h3>
+        
+        <form onSubmit={handleSubmit} className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">이메일</label>
+            <input
+              type="email"
+              value={user.email}
+              disabled
+              className="w-full px-3 py-2 border border-gray-300 rounded bg-gray-100 text-gray-500"
+            />
+            <div className="text-xs text-gray-500 mt-1">이메일은 수정할 수 없습니다</div>
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">이름</label>
+            <input
+              type="text"
+              value={formData.name}
+              onChange={(e) => setFormData({ ...formData, name: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              required
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">권한</label>
+            <select
+              value={formData.role}
+              onChange={(e) => setFormData({ ...formData, role: e.target.value as 'admin' | 'user' })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            >
+              <option value="user">👤 사용자</option>
+              <option value="admin">👨‍💼 관리자</option>
+            </select>
+          </div>
+          
+          <div>
+            <label className="flex items-center gap-2">
+              <input
+                type="checkbox"
+                checked={formData.is_active}
+                onChange={(e) => setFormData({ ...formData, is_active: e.target.checked })}
+                className="rounded"
+              />
+              <span className="text-sm font-medium text-gray-700">계정 활성화</span>
+            </label>
+          </div>
+          
+          <div className="flex gap-2 pt-4">
+            <button
+              type="button"
+              onClick={onClose}
+              className="flex-1 px-4 py-2 border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+            >
+              취소
+            </button>
+            <button
+              type="submit"
+              disabled={isSubmitting}
+              className="flex-1 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50"
+            >
+              {isSubmitting ? '수정 중...' : '수정'}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  )
+}
+
+export default AdminDashboard
diff --git a/src/components/Attractions.tsx b/src/components/Attractions.tsx
index 0662695..75712da 100644
--- a/src/components/Attractions.tsx
+++ b/src/components/Attractions.tsx
@@ -6,10 +6,10 @@ const attractions: Attraction[] = [
     name: 'Kumamoto Castle',
     nameKo: '구마모토성',
     description:
-      '일본 3대 명성 중 하나로, 400년의 역사를 가진 웅장한 성입니다. 2016년 지진으로 일부 손상되었지만 복구 작업이 진행 중입니다.',
+      '1607년 가토 기요마사에 의해 축성된 일본 3대 명성 중 하나. 정교한 돌담과 웅장한 성곽으로 유명하며, 2016년 지진 피해 복구 작업이 진행 중입니다. 천수각과 우토야구라에서 구마모토 시내를 한눈에 볼 수 있습니다.',
     location: '구마모토시 주오구 혼마루 1-1',
     estimatedTime: '2-3시간',
-    admissionFee: 500,
+    admissionFee: 800,
     category: 'castle',
     imageUrl: 'https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=800&q=80',
     coordinates: { lat: 32.8061, lng: 130.7058 },
@@ -19,8 +19,8 @@ const attractions: Attraction[] = [
     name: 'Mount Aso',
     nameKo: '아소산',
     description:
-      '세계 최대 규모의 칼데라를 가진 활화산입니다. 아소산 로프웨이를 타고 분화구를 관람할 수 있습니다.',
-    location: '아소시',
+      '세계 최대 규모의 칼데라(남북 25km, 동서 18km)를 가진 활화산. 나카다케 분화구에서는 에메랄드빛 화구호를 볼 수 있으며, 로프웨이나 셔틀버스로 접근 가능합니다. 화산 활동 상황에 따라 접근이 제한될 수 있습니다.',
+    location: '아소시 나카다케',
     estimatedTime: '반나절',
     admissionFee: 1200,
     category: 'nature',
@@ -32,18 +32,20 @@ const attractions: Attraction[] = [
     name: 'Kurokawa Onsen',
     nameKo: '구로카와 온천',
     description:
-      '일본에서 가장 아름다운 온천 마을 중 하나로, 전통적인 일본 풍경을 즐길 수 있습니다.',
-    location: '아소군 미나미아소무라',
+      '미슐랭 가이드 별 2개를 받은 전통 온천 마을. 30여 개의 료칸이 모여 있으며, "입욕 수첩(1,300엔)"으로 3곳의 노천탕을 체험할 수 있습니다. 자연에 둘러싸인 정취 있는 온천가로 유명합니다.',
+    location: '아소군 미나미오구니마치 만간지',
     estimatedTime: '하루',
+    admissionFee: 1300,
     category: 'onsen',
     imageUrl: 'https://images.unsplash.com/photo-1545569341-9eb8b30979d9?w=800&q=80',
+    coordinates: { lat: 33.0667, lng: 131.1167 },
   },
   {
     id: '4',
     name: 'Suizenji Jojuen Garden',
     nameKo: '수이젠지 조주엔',
     description:
-      '400년 전통의 정원으로, 일본의 미니어처 풍경을 재현한 아름다운 정원입니다.',
+      '1636년 호소카와 가문이 조성한 회유식 일본정원. 도카이도 53차의 풍경을 축소 재현했으며, 특히 후지산을 모방한 인공 언덕이 유명합니다. 정원 내 이즈미 신사에서는 장수의 물을 마실 수 있습니다.',
     location: '구마모토시 주오구 수이젠지 공원 8-1',
     estimatedTime: '1-2시간',
     admissionFee: 400,
@@ -56,30 +58,32 @@ const attractions: Attraction[] = [
     name: 'Amakusa',
     nameKo: '아마쿠사',
     description:
-      '크리스천 다이묘의 역사가 있는 아름다운 섬들로, 바다와 교회가 어우러진 풍경을 즐길 수 있습니다.',
+      '크리스천 다이문의 역사가 있는 아름다운 섬들로, 바다와 교회가 어우러진 풍경을 즐길 수 있습니다.',
     location: '아마쿠사시',
     estimatedTime: '하루',
     category: 'other',
     imageUrl: 'https://images.unsplash.com/photo-1507525428034-b723cf961d3e?w=800&q=80',
+    coordinates: { lat: 32.4833, lng: 130.1833 },
   },
   {
     id: '6',
     name: 'Kumamoto Ramen',
     nameKo: '구마모토 라멘',
     description:
-      '돼지뼈 육수에 마늘 기름을 넣은 구마모토 특유의 라멘을 맛볼 수 있습니다.',
+      '돼지뼈를 우린 진한 돈코츠 육수에 마늘 기름(마유)과 볶은 마늘을 올린 구마모토 특유의 라멘. 면은 중간 굵기의 스트레이트면을 사용하며, 진한 국물과 고소한 마늘향이 특징입니다. 구마모토 시내 곳곳에서 맛볼 수 있습니다.',
     location: '구마모토시 전역',
     estimatedTime: '1시간',
     category: 'food',
     imageUrl: 'https://images.unsplash.com/photo-1569718212165-3a8278d5f624?w=800&q=80',
+    coordinates: { lat: 32.8031, lng: 130.7079 },
   },
   {
     id: '7',
     name: 'Kikuchi Gorge',
     nameKo: '기쿠치협곡',
     description:
-      '아름다운 계곡과 폭포가 있는 자연 명소로, 특히 가을 단풍이 유명합니다.',
-    location: '기쿠치시',
+      '기쿠치강 상류에 위치한 길이 4km의 아름다운 계곡. 맑은 물과 기암괴석, 울창한 숲이 어우러져 사계절 내내 아름다운 풍경을 자랑합니다. 특히 가을 단풍이 유명하며, 산책로를 따라 여러 폭포를 감상할 수 있습니다.',
+    location: '기쿠치시 오리노오 1208',
     estimatedTime: '1-2시간',
     category: 'nature',
     imageUrl: 'https://images.unsplash.com/photo-1501594907352-04cda38ebc29?w=800&q=80',
@@ -90,8 +94,8 @@ const attractions: Attraction[] = [
     name: 'Kusasenri',
     nameKo: '쿠사센리',
     description:
-      '아소산 중턱에 있는 넓은 초원으로, 말 타기와 하이킹을 즐길 수 있습니다.',
-    location: '아소시',
+      '아소산 중턱 해발 1,140m에 위치한 직경 1km의 광활한 초원. 중앙에 작은 연못이 있고, 배경으로 보이는 나카다케 분화구와 함께 아소산의 대표적인 풍경을 이룹니다. 승마 체험과 산책을 즐길 수 있으며, 아소 화산 박물관도 인근에 있습니다.',
+    location: '아소시 아카미즈',
     estimatedTime: '1-2시간',
     category: 'nature',
     imageUrl: 'https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=800&q=80',
@@ -107,7 +111,7 @@ const attractions: Attraction[] = [
     estimatedTime: '30분-1시간',
     category: 'nature',
     imageUrl: 'https://images.unsplash.com/photo-1501594907352-04cda38ebc29?w=800&q=80',
-    coordinates: { lat: 32.8031, lng: 130.7079 },
+    coordinates: { lat: 32.885833, lng: 130.879444 },
   },
   {
     id: '10',
@@ -119,7 +123,7 @@ const attractions: Attraction[] = [
     estimatedTime: '1시간',
     category: 'other',
     imageUrl: 'https://images.unsplash.com/photo-1522383225653-1113756be3d8?w=800&q=80',
-    coordinates: { lat: 32.8031, lng: 130.7079 },
+    coordinates: { lat: 32.807, lng: 130.706 },
   },
   {
     id: '11',
@@ -133,6 +137,67 @@ const attractions: Attraction[] = [
     imageUrl: 'https://images.unsplash.com/photo-1514933651103-005eec06c04b?w=800&q=80',
     coordinates: { lat: 32.8031, lng: 130.7079 },
   },
+  {
+    id: '12',
+    name: 'Shirakawa Suigen',
+    nameKo: '시라카와 수원',
+    description:
+      '매분 60톤의 깨끗한 샘물이 솟아나는 남아소의 대표적인 수원지. 환경성 명수백선에 선정되었으며, 수온은 연중 14도로 일정합니다. 방문객들은 자유롭게 물을 마시거나 가져갈 수 있습니다.',
+    location: '아소군 미나미아소무라 시라카와',
+    estimatedTime: '30분-1시간',
+    category: 'nature',
+    imageUrl: 'https://images.unsplash.com/photo-1501594907352-04cda38ebc29?w=800&q=80',
+    coordinates: { lat: 32.8267, lng: 131.0389 },
+  },
+  {
+    id: '13',
+    name: 'Takachiho Gorge',
+    nameKo: '다카치호 협곡',
+    description:
+      '아소산의 화산 활동으로 형성된 절경의 협곡. 깊이 100m의 절벽과 에메랄드 그린의 강물이 어우러진 신비로운 곳입니다. 보트를 타고 마나이 폭포를 가까이에서 감상할 수 있습니다.',
+    location: '미야자키현 다카치호초',
+    estimatedTime: '2-3시간',
+    admissionFee: 300,
+    category: 'nature',
+    imageUrl: 'https://images.unsplash.com/photo-1506905925346-21bda4d32df4?w=800&q=80',
+    coordinates: { lat: 32.7131, lng: 131.3142 },
+  },
+  {
+    id: '14',
+    name: 'Nabegatataki Falls',
+    nameKo: '나베가타탄키 폭포',
+    description:
+      '낙차 10m, 너비 20m의 웅장한 폭포로 물이 커튼처럼 떨어지는 모습이 인상적입니다. 폭포 뒤쪽에서 조명을 켜는 이벤트도 개최되며, 햇살이 비추면 신비로운 풍경을 연출합니다.',
+    location: '오기군 오기마치',
+    estimatedTime: '1-2시간',
+    category: 'nature',
+    imageUrl: 'https://images.unsplash.com/photo-1501594907352-04cda38ebc29?w=800&q=80',
+    coordinates: { lat: 33.2167, lng: 130.8833 },
+  },
+  {
+    id: '15',
+    name: 'Sakuranobaba Josaien',
+    nameKo: '사쿠라노바바 조사이엔',
+    description:
+      '구마모토성 바로 아래 위치한 역사 문화 체험 시설. 에도 시대 건물을 재현한 공간에서 구마모토의 역사와 문화를 배울 수 있으며, 전통 공예품 쇼핑과 지역 특산품 맛보기가 가능합니다.',
+    location: '구마모토시 주오구 혼마루 1-1',
+    estimatedTime: '1-2시간',
+    category: 'other',
+    imageUrl: 'https://images.unsplash.com/photo-1522383225653-1113756be3d8?w=800&q=80',
+    coordinates: { lat: 32.8061, lng: 130.7058 },
+  },
+  {
+    id: '16',
+    name: 'Kumamon Square',
+    nameKo: '쿠마몬 스퀘어',
+    description:
+      '구마모토의 마스코트 쿠마몬의 공식 샵. 쿠마몬 관련 굿즈를 구매할 수 있고, 운이 좋으면 쿠마몬을 직접 만나볼 수도 있습니다. 아이들과 가족 단위 방문객에게 인기가 높습니다.',
+    location: '구마모토시 주오구 하나바타초 3-35',
+    estimatedTime: '30분-1시간',
+    category: 'other',
+    imageUrl: 'https://images.unsplash.com/photo-1522383225653-1113756be3d8?w=800&q=80',
+    coordinates: { lat: 32.7903, lng: 130.7414 },
+  },
 ]
 
 export { attractions }
diff --git a/src/components/AuthForm.tsx b/src/components/AuthForm.tsx
new file mode 100644
index 0000000..336c09c
--- /dev/null
+++ b/src/components/AuthForm.tsx
@@ -0,0 +1,298 @@
+import { useState } from 'react'
+import { userAuthService, LoginCredentials, RegisterData } from '../services/userAuth'
+
+interface AuthFormProps {
+  onSuccess: () => void
+  className?: string
+}
+
+const AuthForm = ({ onSuccess, className = '' }: AuthFormProps) => {
+  const [mode, setMode] = useState<'login' | 'register'>('login')
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  
+  const [loginData, setLoginData] = useState<LoginCredentials>({
+    email: '',
+    password: ''
+  })
+  
+  const [registerData, setRegisterData] = useState<RegisterData>({
+    email: '',
+    password: '',
+    name: ''
+  })
+
+  const handleLogin = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+    setError(null)
+
+    try {
+      const result = await userAuthService.login(loginData)
+      if (result.success) {
+        onSuccess()
+      } else {
+        setError(result.message || '로그인에 실패했습니다')
+      }
+    } catch (error) {
+      setError('로그인 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  const handleRegister = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+    setError(null)
+
+    try {
+      const result = await userAuthService.register(registerData)
+      if (result.success) {
+        onSuccess()
+      } else {
+        setError(result.message || '회원가입에 실패했습니다')
+      }
+    } catch (error) {
+      setError('회원가입 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  const handleDemoLogin = async (role: 'admin' | 'user') => {
+    setIsSubmitting(true)
+    setError(null)
+
+    const demoCredentials = {
+      admin: { email: 'admin@travel.com', password: 'admin123' },
+      user: { email: 'demo@travel.com', password: 'demo123' }
+    }
+
+    // 데모 사용자가 없으면 생성
+    if (role === 'user') {
+      try {
+        await userAuthService.register({
+          email: 'demo@travel.com',
+          password: 'demo123',
+          name: '데모 사용자'
+        })
+      } catch (error) {
+        // 이미 존재하는 경우 무시
+      }
+    }
+
+    try {
+      const result = await userAuthService.login(demoCredentials[role])
+      if (result.success) {
+        onSuccess()
+      } else {
+        setError(result.message || '데모 로그인에 실패했습니다')
+      }
+    } catch (error) {
+      setError('데모 로그인 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  return (
+    <div className={`bg-white rounded-lg shadow-lg p-8 w-full max-w-md ${className}`}>
+      {/* 헤더 */}
+      <div className="text-center mb-8">
+        <div className="text-4xl mb-4">🗺️</div>
+        <h2 className="text-2xl font-bold text-gray-800 mb-2">
+          {mode === 'login' ? '로그인' : '회원가입'}
+        </h2>
+        <p className="text-gray-600">
+          {mode === 'login' 
+            ? '여행 계획을 관리하려면 로그인하세요' 
+            : '새 계정을 만들어 여행 계획을 시작하세요'
+          }
+        </p>
+      </div>
+
+      {/* 에러 메시지 */}
+      {error && (
+        <div className="mb-6 p-3 bg-red-50 border border-red-200 rounded-lg">
+          <div className="flex items-center gap-2 text-red-700">
+            <span>⚠️</span>
+            <span className="text-sm">{error}</span>
+          </div>
+        </div>
+      )}
+
+      {/* 데모 계정 버튼 */}
+      <div className="mb-6 p-4 bg-blue-50 border border-blue-200 rounded-lg">
+        <div className="text-sm font-medium text-blue-800 mb-3">🚀 빠른 체험</div>
+        <div className="flex gap-2">
+          <button
+            onClick={() => handleDemoLogin('admin')}
+            disabled={isSubmitting}
+            className="flex-1 px-3 py-2 bg-purple-600 text-white text-sm rounded hover:bg-purple-700 disabled:opacity-50"
+          >
+            👨‍💼 관리자로 체험
+          </button>
+          <button
+            onClick={() => handleDemoLogin('user')}
+            disabled={isSubmitting}
+            className="flex-1 px-3 py-2 bg-blue-600 text-white text-sm rounded hover:bg-blue-700 disabled:opacity-50"
+          >
+            👤 사용자로 체험
+          </button>
+        </div>
+        <div className="text-xs text-blue-600 mt-2">
+          • 관리자: 모든 사용자와 여행 일정 관리<br/>
+          • 사용자: 개인 여행 일정 생성 및 관리
+        </div>
+      </div>
+
+      <div className="relative mb-6">
+        <div className="absolute inset-0 flex items-center">
+          <div className="w-full border-t border-gray-300" />
+        </div>
+        <div className="relative flex justify-center text-sm">
+          <span className="px-2 bg-white text-gray-500">또는</span>
+        </div>
+      </div>
+
+      {/* 로그인 폼 */}
+      {mode === 'login' && (
+        <form onSubmit={handleLogin} className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              이메일
+            </label>
+            <input
+              type="email"
+              value={loginData.email}
+              onChange={(e) => setLoginData({ ...loginData, email: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              placeholder="example@email.com"
+              required
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              비밀번호
+            </label>
+            <input
+              type="password"
+              value={loginData.password}
+              onChange={(e) => setLoginData({ ...loginData, password: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              placeholder="비밀번호를 입력하세요"
+              required
+            />
+          </div>
+          
+          <button
+            type="submit"
+            disabled={isSubmitting}
+            className="w-full py-3 px-4 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+          >
+            {isSubmitting ? (
+              <div className="flex items-center justify-center gap-2">
+                <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                로그인 중...
+              </div>
+            ) : (
+              '로그인'
+            )}
+          </button>
+        </form>
+      )}
+
+      {/* 회원가입 폼 */}
+      {mode === 'register' && (
+        <form onSubmit={handleRegister} className="space-y-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              이름
+            </label>
+            <input
+              type="text"
+              value={registerData.name}
+              onChange={(e) => setRegisterData({ ...registerData, name: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              placeholder="홍길동"
+              required
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              이메일
+            </label>
+            <input
+              type="email"
+              value={registerData.email}
+              onChange={(e) => setRegisterData({ ...registerData, email: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              placeholder="example@email.com"
+              required
+            />
+          </div>
+          
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              비밀번호
+            </label>
+            <input
+              type="password"
+              value={registerData.password}
+              onChange={(e) => setRegisterData({ ...registerData, password: e.target.value })}
+              className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+              placeholder="6자 이상 입력하세요"
+              required
+              minLength={6}
+            />
+          </div>
+          
+          <button
+            type="submit"
+            disabled={isSubmitting}
+            className="w-full py-3 px-4 bg-green-600 text-white rounded-lg hover:bg-green-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+          >
+            {isSubmitting ? (
+              <div className="flex items-center justify-center gap-2">
+                <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                가입 중...
+              </div>
+            ) : (
+              '회원가입'
+            )}
+          </button>
+        </form>
+      )}
+
+      {/* 모드 전환 */}
+      <div className="mt-6 text-center">
+        <button
+          onClick={() => {
+            setMode(mode === 'login' ? 'register' : 'login')
+            setError(null)
+          }}
+          className="text-blue-600 hover:text-blue-800 text-sm"
+        >
+          {mode === 'login' 
+            ? '계정이 없으신가요? 회원가입' 
+            : '이미 계정이 있으신가요? 로그인'
+          }
+        </button>
+      </div>
+
+      {/* 개발 정보 */}
+      <div className="mt-6 p-3 bg-gray-50 border border-gray-200 rounded-lg">
+        <div className="text-xs text-gray-600">
+          <div className="font-medium mb-1">💡 개발 버전 안내</div>
+          <div>• 관리자: admin@travel.com / admin123</div>
+          <div>• 데이터는 브라우저에 저장됩니다</div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default AuthForm
diff --git a/src/components/DebugInfo.tsx b/src/components/DebugInfo.tsx
new file mode 100644
index 0000000..d92a9c2
--- /dev/null
+++ b/src/components/DebugInfo.tsx
@@ -0,0 +1,164 @@
+import { useState, useEffect } from 'react'
+import { userAuthService } from '../services/userAuth'
+import { initialSetupService } from '../services/initialSetup'
+
+const DebugInfo = () => {
+  const [debugInfo, setDebugInfo] = useState({
+    isSetupComplete: false,
+    isAuthenticated: false,
+    currentUser: null as any,
+    error: null as string | null
+  })
+
+  useEffect(() => {
+    const checkStatus = async () => {
+      try {
+        const setupStatus = await initialSetupService.checkSetupStatus()
+        const authStatus = userAuthService.isAuthenticated()
+        const currentUser = userAuthService.getCurrentUser()
+
+        setDebugInfo({
+          isSetupComplete: setupStatus.isSetupComplete,
+          isAuthenticated: authStatus,
+          currentUser: currentUser,
+          error: null
+        })
+      } catch (error) {
+        setDebugInfo(prev => ({
+          ...prev,
+          error: error instanceof Error ? error.message : '알 수 없는 오류'
+        }))
+      }
+    }
+
+    checkStatus()
+  }, [])
+
+  const handleCreateTestUser = async () => {
+    try {
+      // 테스트 관리자 계정 생성
+      const result = await initialSetupService.createInitialAdmin({
+        name: '테스트 관리자',
+        email: 'admin@test.com',
+        password: 'admin123'
+      })
+
+      if (result.success) {
+        alert('테스트 관리자 계정이 생성되었습니다!\n이메일: admin@test.com\n비밀번호: admin123')
+        window.location.reload()
+      } else {
+        alert(`계정 생성 실패: ${result.message}`)
+      }
+    } catch (error) {
+      alert(`오류 발생: ${error}`)
+    }
+  }
+
+  const handleLogin = async () => {
+    try {
+      const result = await userAuthService.login({
+        email: 'admin@test.com',
+        password: 'admin123'
+      })
+
+      if (result.success) {
+        alert('로그인 성공!')
+        window.location.reload()
+      } else {
+        alert(`로그인 실패: ${result.message}`)
+      }
+    } catch (error) {
+      alert(`로그인 오류: ${error}`)
+    }
+  }
+
+  return (
+    <div className="min-h-screen bg-gray-100 p-8">
+      <div className="max-w-2xl mx-auto bg-white rounded-lg shadow-md p-6">
+        <h1 className="text-2xl font-bold text-gray-800 mb-6">🔍 디버그 정보</h1>
+        
+        <div className="space-y-4">
+          <div className="p-4 bg-gray-50 rounded-lg">
+            <h3 className="font-semibold text-gray-800 mb-2">현재 상태</h3>
+            <div className="space-y-2 text-sm">
+              <div className="flex justify-between">
+                <span>초기 설정 완료:</span>
+                <span className={debugInfo.isSetupComplete ? 'text-green-600' : 'text-red-600'}>
+                  {debugInfo.isSetupComplete ? '✅ 완료' : '❌ 미완료'}
+                </span>
+              </div>
+              <div className="flex justify-between">
+                <span>로그인 상태:</span>
+                <span className={debugInfo.isAuthenticated ? 'text-green-600' : 'text-red-600'}>
+                  {debugInfo.isAuthenticated ? '✅ 로그인됨' : '❌ 로그아웃'}
+                </span>
+              </div>
+              <div className="flex justify-between">
+                <span>현재 사용자:</span>
+                <span className="text-gray-600">
+                  {debugInfo.currentUser ? debugInfo.currentUser.name : '없음'}
+                </span>
+              </div>
+              {debugInfo.error && (
+                <div className="flex justify-between">
+                  <span>오류:</span>
+                  <span className="text-red-600">{debugInfo.error}</span>
+                </div>
+              )}
+            </div>
+          </div>
+
+          <div className="p-4 bg-blue-50 rounded-lg">
+            <h3 className="font-semibold text-gray-800 mb-2">로컬 스토리지 정보</h3>
+            <div className="space-y-2 text-sm">
+              <div>
+                <strong>dev_setup_complete:</strong> {localStorage.getItem('dev_setup_complete') || '없음'}
+              </div>
+              <div>
+                <strong>dev_auth_token:</strong> {localStorage.getItem('dev_auth_token') ? '있음' : '없음'}
+              </div>
+              <div>
+                <strong>dev_current_user:</strong> {localStorage.getItem('dev_current_user') ? '있음' : '없음'}
+              </div>
+            </div>
+          </div>
+
+          <div className="space-y-3">
+            <button
+              onClick={handleCreateTestUser}
+              className="w-full px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+            >
+              🔧 테스트 관리자 계정 생성
+            </button>
+            
+            <button
+              onClick={handleLogin}
+              className="w-full px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700"
+            >
+              🔑 테스트 계정으로 로그인
+            </button>
+
+            <button
+              onClick={() => {
+                localStorage.clear()
+                window.location.reload()
+              }}
+              className="w-full px-4 py-2 bg-red-600 text-white rounded hover:bg-red-700"
+            >
+              🗑️ 모든 데이터 초기화
+            </button>
+
+            <button
+              onClick={() => window.location.href = '/'}
+              className="w-full px-4 py-2 bg-gray-600 text-white rounded hover:bg-gray-700"
+            >
+              🏠 메인 페이지로 이동
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default DebugInfo
diff --git a/src/components/DynamicMap.tsx b/src/components/DynamicMap.tsx
new file mode 100644
index 0000000..db4d8f1
--- /dev/null
+++ b/src/components/DynamicMap.tsx
@@ -0,0 +1,80 @@
+import { useEffect, useState } from 'react'
+import { Attraction } from '../types'
+
+interface MapProps {
+  attractions: Attraction[]
+}
+
+const DynamicMap = ({ attractions }: MapProps) => {
+  const [MapComponent, setMapComponent] = useState<React.ComponentType<MapProps> | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  useEffect(() => {
+    // 동적으로 Map 컴포넌트 로드 (클라이언트에서만)
+    const loadMap = async () => {
+      try {
+        const { default: KumamotoMap } = await import('./Map')
+        setMapComponent(() => KumamotoMap)
+        setIsLoading(false)
+      } catch (err) {
+        console.error('Map 컴포넌트 로드 실패:', err)
+        setError('지도를 불러올 수 없습니다.')
+        setIsLoading(false)
+      }
+    }
+
+    // 클라이언트에서만 실행
+    if (typeof window !== 'undefined') {
+      loadMap()
+    }
+  }, [])
+
+  if (isLoading) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-gray-100">
+          <div className="text-center">
+            <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-kumamoto-blue mx-auto mb-2"></div>
+            <p className="text-gray-500">지도를 불러오는 중...</p>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-red-50">
+          <div className="text-center">
+            <p className="text-red-500 mb-2">⚠️ {error}</p>
+            <button 
+              onClick={() => window.location.reload()} 
+              className="px-4 py-2 bg-red-500 text-white rounded hover:bg-red-600"
+            >
+              새로고침
+            </button>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  if (!MapComponent) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-gray-100">
+          <p className="text-gray-500">지도 컴포넌트를 찾을 수 없습니다.</p>
+        </div>
+      </div>
+    )
+  }
+
+  return <MapComponent attractions={attractions} />
+}
+
+export default DynamicMap
diff --git a/src/components/GoogleAuthManager.tsx b/src/components/GoogleAuthManager.tsx
new file mode 100644
index 0000000..eefa2b3
--- /dev/null
+++ b/src/components/GoogleAuthManager.tsx
@@ -0,0 +1,285 @@
+import { useState, useEffect } from 'react'
+import { googleAuthService, GoogleUser, SavedPlace, GoogleMyMap } from '../services/googleAuth'
+
+interface GoogleAuthManagerProps {
+  onSavedPlacesLoad?: (places: SavedPlace[]) => void
+  onMyMapsLoad?: (maps: GoogleMyMap[]) => void
+  className?: string
+}
+
+const GoogleAuthManager = ({ onSavedPlacesLoad, onMyMapsLoad, className = '' }: GoogleAuthManagerProps) => {
+  const [user, setUser] = useState<GoogleUser | null>(null)
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [savedPlaces, setSavedPlaces] = useState<SavedPlace[]>([])
+  const [myMaps, setMyMaps] = useState<GoogleMyMap[]>([])
+  const [isInitialized, setIsInitialized] = useState(false)
+
+  useEffect(() => {
+    // 컴포넌트 마운트 시 초기화
+    initializeAuth()
+  }, [])
+
+  const initializeAuth = async () => {
+    try {
+      // 환경변수에서 Client ID 가져오기 (없으면 사용자 입력 받기)
+      const clientId = import.meta.env.VITE_GOOGLE_OAUTH_CLIENT_ID || 
+                      localStorage.getItem('google_oauth_client_id')
+      
+      if (!clientId) {
+        setError('Google OAuth Client ID가 필요합니다')
+        return
+      }
+
+      await googleAuthService.initialize(clientId)
+      setIsInitialized(true)
+      
+      // 이미 로그인된 사용자가 있는지 확인
+      const currentUser = googleAuthService.getCurrentUser()
+      if (currentUser && googleAuthService.isSignedIn()) {
+        setUser(currentUser)
+        await loadUserData()
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Google Auth 초기화 실패')
+    }
+  }
+
+  const handleSignIn = async () => {
+    if (!isInitialized) {
+      setError('Google Auth가 초기화되지 않았습니다')
+      return
+    }
+
+    setIsLoading(true)
+    setError(null)
+
+    try {
+      const signedInUser = await googleAuthService.signIn()
+      setUser(signedInUser)
+      await loadUserData()
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '로그인 실패')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleSignOut = async () => {
+    setIsLoading(true)
+    
+    try {
+      await googleAuthService.signOut()
+      setUser(null)
+      setSavedPlaces([])
+      setMyMaps([])
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '로그아웃 실패')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const loadUserData = async () => {
+    try {
+      setIsLoading(true)
+      
+      // 저장된 장소 로드
+      const places = await googleAuthService.getSavedPlaces()
+      setSavedPlaces(places)
+      if (onSavedPlacesLoad) {
+        onSavedPlacesLoad(places)
+      }
+
+      // My Maps 로드
+      const maps = await googleAuthService.getMyMaps()
+      setMyMaps(maps)
+      if (onMyMapsLoad) {
+        onMyMapsLoad(maps)
+      }
+    } catch (err) {
+      console.error('사용자 데이터 로드 실패:', err)
+      setError('데이터 로드 실패 (캐시된 데이터 사용)')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleAddToItinerary = (place: SavedPlace) => {
+    const itineraryItem = googleAuthService.convertToItineraryFormat(place)
+    // 부모 컴포넌트로 전달하거나 직접 일정에 추가
+    console.log('일정에 추가:', itineraryItem)
+    alert(`"${place.name}"을(를) 일정에 추가했습니다!`)
+  }
+
+  // Client ID 설정 (개발용)
+  const handleSetClientId = () => {
+    const clientId = prompt('Google OAuth Client ID를 입력하세요:')
+    if (clientId) {
+      localStorage.setItem('google_oauth_client_id', clientId)
+      window.location.reload()
+    }
+  }
+
+  return (
+    <div className={`bg-white rounded-lg shadow-md p-6 ${className}`}>
+      <div className="flex items-center justify-between mb-4">
+        <h3 className="text-lg font-semibold text-gray-800">🔐 Google 계정 연동</h3>
+        {!isInitialized && (
+          <button
+            onClick={handleSetClientId}
+            className="text-sm text-blue-600 hover:text-blue-800"
+          >
+            Client ID 설정
+          </button>
+        )}
+      </div>
+
+      {error && (
+        <div className="mb-4 p-3 bg-red-50 border border-red-200 rounded-lg">
+          <div className="flex items-center gap-2 text-red-700">
+            <span>⚠️</span>
+            <span className="text-sm">{error}</span>
+          </div>
+        </div>
+      )}
+
+      {!user ? (
+        <div className="text-center">
+          <div className="mb-4">
+            <div className="text-4xl mb-2">🗺️</div>
+            <p className="text-gray-600 mb-2">Google Maps에 저장된 장소를 가져와서</p>
+            <p className="text-gray-600">구마모토 여행 계획에 추가하세요!</p>
+          </div>
+          
+          <button
+            onClick={handleSignIn}
+            disabled={isLoading || !isInitialized}
+            className="w-full py-3 px-4 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed transition-colors flex items-center justify-center gap-2"
+          >
+            {isLoading ? (
+              <>
+                <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                연결 중...
+              </>
+            ) : (
+              <>
+                <svg className="w-5 h-5" viewBox="0 0 24 24">
+                  <path fill="currentColor" d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"/>
+                  <path fill="currentColor" d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"/>
+                  <path fill="currentColor" d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"/>
+                  <path fill="currentColor" d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"/>
+                </svg>
+                Google로 로그인
+              </>
+            )}
+          </button>
+
+          <div className="mt-4 text-xs text-gray-500">
+            <p>• Google My Maps의 저장된 장소</p>
+            <p>• 즐겨찾기 및 가고 싶은 곳 리스트</p>
+            <p>• 개인 여행 계획 및 메모</p>
+          </div>
+        </div>
+      ) : (
+        <div>
+          {/* 사용자 정보 */}
+          <div className="flex items-center gap-3 mb-4 p-3 bg-gray-50 rounded-lg">
+            <img
+              src={user.picture}
+              alt={user.name}
+              className="w-10 h-10 rounded-full"
+            />
+            <div className="flex-1">
+              <div className="font-medium text-gray-800">{user.name}</div>
+              <div className="text-sm text-gray-600">{user.email}</div>
+            </div>
+            <button
+              onClick={handleSignOut}
+              className="text-sm text-gray-500 hover:text-gray-700"
+            >
+              로그아웃
+            </button>
+          </div>
+
+          {/* 데이터 새로고침 */}
+          <div className="flex gap-2 mb-4">
+            <button
+              onClick={loadUserData}
+              disabled={isLoading}
+              className="flex-1 py-2 px-3 bg-blue-100 text-blue-700 rounded hover:bg-blue-200 disabled:opacity-50 text-sm"
+            >
+              {isLoading ? '로딩...' : '🔄 데이터 새로고침'}
+            </button>
+          </div>
+
+          {/* My Maps 목록 */}
+          {myMaps.length > 0 && (
+            <div className="mb-4">
+              <h4 className="font-medium text-gray-800 mb-2">📋 My Maps ({myMaps.length}개)</h4>
+              <div className="space-y-2 max-h-40 overflow-y-auto">
+                {myMaps.map((map) => (
+                  <div key={map.id} className="p-2 bg-gray-50 rounded border">
+                    <div className="font-medium text-sm">{map.title}</div>
+                    <div className="text-xs text-gray-600">
+                      {map.places.length}개 장소 • {new Date(map.updated_date).toLocaleDateString()}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+
+          {/* 저장된 장소 목록 */}
+          {savedPlaces.length > 0 && (
+            <div>
+              <h4 className="font-medium text-gray-800 mb-2">⭐ 저장된 장소 ({savedPlaces.length}개)</h4>
+              <div className="space-y-2 max-h-60 overflow-y-auto">
+                {savedPlaces.slice(0, 10).map((place) => (
+                  <div key={place.place_id} className="p-3 bg-gray-50 rounded border hover:bg-gray-100 transition-colors">
+                    <div className="flex justify-between items-start">
+                      <div className="flex-1 min-w-0">
+                        <div className="font-medium text-sm text-gray-800 truncate">
+                          {place.name}
+                        </div>
+                        <div className="text-xs text-gray-600 truncate">
+                          {place.formatted_address}
+                        </div>
+                        {place.rating && (
+                          <div className="text-xs text-yellow-600 mt-1">
+                            ⭐ {place.rating} {place.user_ratings_total && `(${place.user_ratings_total})`}
+                          </div>
+                        )}
+                      </div>
+                      <button
+                        onClick={() => handleAddToItinerary(place)}
+                        className="ml-2 px-2 py-1 bg-kumamoto-primary text-white text-xs rounded hover:bg-kumamoto-primary/90"
+                      >
+                        추가
+                      </button>
+                    </div>
+                  </div>
+                ))}
+                {savedPlaces.length > 10 && (
+                  <div className="text-center text-sm text-gray-500">
+                    +{savedPlaces.length - 10}개 더 있음
+                  </div>
+                )}
+              </div>
+            </div>
+          )}
+
+          {savedPlaces.length === 0 && myMaps.length === 0 && !isLoading && (
+            <div className="text-center py-8 text-gray-500">
+              <div className="text-4xl mb-2">📭</div>
+              <p>저장된 장소나 My Maps가 없습니다</p>
+              <p className="text-sm mt-1">Google Maps에서 장소를 저장해보세요!</p>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default GoogleAuthManager
diff --git a/src/components/GoogleMapComponent.tsx b/src/components/GoogleMapComponent.tsx
new file mode 100644
index 0000000..ee3c8a3
--- /dev/null
+++ b/src/components/GoogleMapComponent.tsx
@@ -0,0 +1,497 @@
+import { useEffect, useState, useCallback } from 'react'
+import { Attraction, BasePoint } from '../types'
+import { basePointsAPI } from '../services/api'
+import { canUseGoogleMaps, incrementGoogleMapsUsage } from '../services/googleMapsUsage'
+import GoogleMapsUsageIndicator from './GoogleMapsUsageIndicator'
+import GoogleMapsApiKeyManager from './GoogleMapsApiKeyManager'
+import { getGoogleMapsApiKey } from '../services/apiKeyManager'
+import { googleDirectionsService } from '../services/googleDirections'
+
+interface GoogleMapComponentProps {
+  attractions: Attraction[]
+  basePoints: BasePoint[]
+  onBasePointsUpdate?: (basePoints: BasePoint[]) => void
+  selectedActivityId?: string
+  currentDaySchedule?: any
+  onActivityClick?: (activity: any) => void
+  getActivityCoords?: (activity: any) => [number, number] | null
+  onMapInit?: (map: google.maps.Map) => void
+}
+
+declare global {
+  interface Window {
+    google: any
+    initGoogleMap: () => void
+  }
+}
+
+const GoogleMapComponent = ({ 
+  attractions, 
+  basePoints, 
+  onBasePointsUpdate,
+  selectedActivityId,
+  currentDaySchedule,
+  onActivityClick,
+  getActivityCoords,
+  onMapInit
+}: GoogleMapComponentProps) => {
+  const [map, setMap] = useState<any>(null)
+  const [isLoaded, setIsLoaded] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [showAddForm, setShowAddForm] = useState(false)
+  const [formData, setFormData] = useState({
+    name: '',
+    address: '',
+    type: 'accommodation' as BasePoint['type'],
+    memo: ''
+  })
+  const [selectedLocation, setSelectedLocation] = useState<{ lat: number; lng: number } | null>(null)
+  const [usageBlocked, setUsageBlocked] = useState(false)
+  const [forceLeaflet, setForceLeaflet] = useState(false)
+  const [hasValidApiKey, setHasValidApiKey] = useState(false)
+  const [currentApiKey, setCurrentApiKey] = useState<string | null>(null)
+
+  // API 키 동적 로드
+  useEffect(() => {
+    const key = getGoogleMapsApiKey()
+    setCurrentApiKey(key)
+  }, [hasValidApiKey])
+
+  // 구마모토 중심 좌표
+  const kumamotoCenter = { lat: 32.8031, lng: 130.7079 }
+
+  const initializeMap = useCallback(() => {
+    if (!window.google || !document.getElementById('google-map')) return
+
+    // API 사용량 체크
+    const usageCheck = canUseGoogleMaps()
+    if (!usageCheck.allowed) {
+      setError(`구글 맵 사용량 한도 초과: ${usageCheck.reason}`)
+      setUsageBlocked(true)
+      return
+    }
+
+    // API 사용량 증가
+    incrementGoogleMapsUsage()
+
+    try {
+      const mapInstance = new window.google.maps.Map(document.getElementById('google-map'), {
+        center: kumamotoCenter,
+        zoom: 10,
+        mapTypeControl: true,
+        streetViewControl: true,
+        fullscreenControl: true,
+      })
+
+      setMap(mapInstance)
+
+      // Directions Service 초기화
+      googleDirectionsService.initialize()
+
+      // onMapInit 콜백 호출
+      if (onMapInit) {
+        onMapInit(mapInstance)
+      }
+
+      // 클릭 이벤트로 위치 선택
+      mapInstance.addListener('click', (event: any) => {
+        if (showAddForm) {
+          setSelectedLocation({
+            lat: event.latLng.lat(),
+            lng: event.latLng.lng()
+          })
+        }
+      })
+
+      // 관광지 마커 추가
+      attractions.forEach((attraction) => {
+        if (attraction.coordinates) {
+          const marker = new window.google.maps.Marker({
+            position: { lat: attraction.coordinates.lat, lng: attraction.coordinates.lng },
+            map: mapInstance,
+            title: attraction.nameKo,
+            icon: {
+              url: 'https://maps.google.com/mapfiles/ms/icons/red-dot.png',
+              scaledSize: new window.google.maps.Size(32, 32)
+            }
+          })
+
+          const infoWindow = new window.google.maps.InfoWindow({
+            content: `
+              <div style="max-width: 300px;">
+                <h3 style="margin: 0 0 8px 0; font-weight: bold; color: #1f2937;">${attraction.nameKo}</h3>
+                <p style="margin: 0 0 8px 0; font-size: 14px; color: #4b5563;">${attraction.description}</p>
+                <p style="margin: 0; font-size: 12px; color: #6b7280;">📍 ${attraction.location}</p>
+                ${attraction.admissionFee ? `<p style="margin: 4px 0 0 0; font-size: 12px; color: #6b7280;">💰 입장료: ${attraction.admissionFee.toLocaleString()}엔</p>` : ''}
+              </div>
+            `
+          })
+
+          marker.addListener('click', () => {
+            infoWindow.open(mapInstance, marker)
+          })
+        }
+      })
+
+      // 기본 포인트 마커 추가
+      basePoints.forEach((point) => {
+        const marker = new window.google.maps.Marker({
+          position: { lat: point.coordinates.lat, lng: point.coordinates.lng },
+          map: mapInstance,
+          title: point.name,
+          icon: {
+            url: 'https://maps.google.com/mapfiles/ms/icons/purple-dot.png',
+            scaledSize: new window.google.maps.Size(32, 32)
+          }
+        })
+
+        const infoWindow = new window.google.maps.InfoWindow({
+          content: `
+            <div style="max-width: 300px;">
+              <h3 style="margin: 0 0 8px 0; font-weight: bold; color: #1f2937;">${getTypeEmoji(point.type)} ${point.name}</h3>
+              <p style="margin: 0 0 8px 0; font-size: 14px; color: #4b5563;">📍 ${point.address}</p>
+              ${point.memo ? `<p style="margin: 0; font-size: 12px; color: #6b7280;">📝 ${point.memo}</p>` : ''}
+            </div>
+          `
+        })
+
+        marker.addListener('click', () => {
+          infoWindow.open(mapInstance, marker)
+        })
+      })
+
+      setIsLoaded(true)
+    } catch (err) {
+      console.error('Google Maps initialization error:', err)
+      setError('구글 맵을 초기화할 수 없습니다.')
+    }
+  }, [attractions, basePoints, showAddForm])
+
+  useEffect(() => {
+    const apiKey = getGoogleMapsApiKey()
+    if (!apiKey) {
+      setError('Google Maps API 키가 설정되지 않았습니다.')
+      return
+    }
+
+    // 초기 사용량 체크
+    const usageCheck = canUseGoogleMaps()
+    if (!usageCheck.allowed) {
+      setError(`구글 맵 사용량 한도 초과: ${usageCheck.reason}`)
+      setUsageBlocked(true)
+      return
+    }
+
+    // Google Maps API 로드
+    if (!window.google) {
+      window.initGoogleMap = initializeMap
+      
+      const script = document.createElement('script')
+      script.src = `https://maps.googleapis.com/maps/api/js?key=${apiKey}&callback=initGoogleMap&libraries=places`
+      script.async = true
+      script.defer = true
+      script.onerror = () => setError('Google Maps API를 로드할 수 없습니다.')
+      document.head.appendChild(script)
+    } else {
+      initializeMap()
+    }
+
+    return () => {
+      // 클린업
+      if (window.initGoogleMap) {
+        delete window.initGoogleMap
+      }
+    }
+  }, [currentApiKey, initializeMap])
+
+  const getTypeEmoji = (type: BasePoint['type']) => {
+    switch (type) {
+      case 'accommodation': return '🏨'
+      case 'airport': return '✈️'
+      case 'station': return '🚉'
+      case 'parking': return '🅿️'
+      default: return '📍'
+    }
+  }
+
+  const getTypeName = (type: BasePoint['type']) => {
+    switch (type) {
+      case 'accommodation': return '숙소'
+      case 'airport': return '공항'
+      case 'station': return '역/정류장'
+      case 'parking': return '주차장'
+      default: return '기타'
+    }
+  }
+
+  const addBasePoint = async () => {
+    if (!formData.name || !formData.address || !selectedLocation) {
+      alert('이름, 주소를 입력하고 지도에서 위치를 클릭해주세요.')
+      return
+    }
+
+    try {
+      const newPoint = await basePointsAPI.create({
+        name: formData.name,
+        address: formData.address,
+        type: formData.type,
+        coordinates: selectedLocation,
+        memo: formData.memo || undefined
+      })
+
+      const updatedBasePoints = [...basePoints, newPoint]
+      onBasePointsUpdate(updatedBasePoints)
+
+      // 폼 초기화
+      setFormData({
+        name: '',
+        address: '',
+        type: 'accommodation',
+        memo: ''
+      })
+      setSelectedLocation(null)
+      setShowAddForm(false)
+
+      // 지도 다시 초기화 (새 마커 추가를 위해)
+      setTimeout(initializeMap, 100)
+    } catch (error) {
+      console.error('Failed to add base point:', error)
+      alert('기본 포인트 추가에 실패했습니다.')
+    }
+  }
+
+  const deleteBasePoint = async (id: string) => {
+    if (confirm('이 위치를 삭제하시겠습니까?')) {
+      try {
+        await basePointsAPI.delete(id)
+        const updatedBasePoints = basePoints.filter(p => p.id !== id)
+        onBasePointsUpdate(updatedBasePoints)
+        
+        // 지도 다시 초기화 (마커 제거를 위해)
+        setTimeout(initializeMap, 100)
+      } catch (error) {
+        console.error('Failed to delete base point:', error)
+        alert('기본 포인트 삭제에 실패했습니다.')
+      }
+    }
+  }
+
+  const handleUsageExceeded = () => {
+    setUsageBlocked(true)
+    setForceLeaflet(true)
+  }
+
+  if (error) {
+    return (
+      <div className="space-y-4">
+        {/* 사용량 초과로 인한 에러인 경우 오픈소스 맵으로 전환 제안 */}
+        {usageBlocked && (
+          <div className="p-4 bg-yellow-50 border border-yellow-200 rounded-lg">
+            <div className="flex items-center gap-2 mb-2">
+              <span className="text-yellow-600">⚠️</span>
+              <span className="font-medium text-yellow-800">구글 맵 사용량 한도 초과</span>
+            </div>
+            <p className="text-sm text-yellow-700 mb-3">
+              구글 맵 API의 무료 사용량을 초과했습니다. 오픈소스 맵(OpenStreetMap)으로 전환하시겠습니까?
+            </p>
+            <button
+              onClick={() => setForceLeaflet(true)}
+              className="px-4 py-2 bg-yellow-600 text-white rounded hover:bg-yellow-700 text-sm"
+            >
+              🌍 오픈소스 맵으로 전환
+            </button>
+          </div>
+        )}
+        
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-red-50">
+          <div className="text-center">
+            <p className="text-red-500 mb-2">⚠️ {error}</p>
+            {!currentApiKey && (
+              <div className="text-sm text-gray-600">
+                <p>Google Maps를 사용하려면 API 키가 필요합니다.</p>
+                <p className="mt-1">아래 API 키 관리자에서 설정해주세요.</p>
+              </div>
+            )}
+            {usageBlocked && (
+              <div className="text-sm text-gray-600 mt-2">
+                <p>무료 사용량을 초과했습니다.</p>
+                <p>내일 다시 시도하거나 오픈소스 맵을 사용해주세요.</p>
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  // 사용량 초과로 강제 전환된 경우
+  if (forceLeaflet) {
+    return (
+      <div className="space-y-4">
+        <div className="p-4 bg-blue-50 border border-blue-200 rounded-lg">
+          <div className="flex items-center gap-2 mb-2">
+            <span className="text-blue-600">🌍</span>
+            <span className="font-medium text-blue-800">오픈소스 맵으로 전환됨</span>
+          </div>
+          <p className="text-sm text-blue-700">
+            구글 맵 사용량 한도로 인해 OpenStreetMap으로 전환되었습니다. 모든 기능은 동일하게 사용 가능합니다.
+          </p>
+        </div>
+        <div className="text-center py-8 text-gray-500">
+          오픈소스 맵 컴포넌트를 로드하는 중...
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div>
+      {/* API 키 관리 */}
+      <div className="mb-4">
+        <GoogleMapsApiKeyManager onApiKeyChange={setHasValidApiKey} />
+      </div>
+
+      {/* Google Maps 사용량 표시 */}
+      {hasValidApiKey && (
+        <div className="mb-4">
+          <GoogleMapsUsageIndicator onUsageExceeded={handleUsageExceeded} />
+        </div>
+      )}
+      {/* 기본 정보 추가 버튼 */}
+      <div className="mb-4 flex justify-end">
+        <button
+          onClick={() => setShowAddForm(!showAddForm)}
+          className="px-4 py-2 bg-kumamoto-primary text-white rounded hover:bg-kumamoto-secondary transition-colors"
+        >
+          {showAddForm ? '닫기' : '+ 기본 정보 추가'}
+        </button>
+      </div>
+
+      {/* 기본 정보 추가 폼 */}
+      {showAddForm && (
+        <div className="mb-6 p-4 bg-gray-50 rounded-lg border border-gray-200">
+          <h3 className="font-semibold text-gray-800 mb-4">기본 정보 추가 (숙소, 공항, 이동 포인트)</h3>
+          <div className="space-y-3">
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">이름</label>
+              <input
+                type="text"
+                value={formData.name}
+                onChange={(e) => setFormData({ ...formData, name: e.target.value })}
+                placeholder="예: 호텔 이름, 구마모토 공항 등"
+                className="w-full px-3 py-2 border rounded"
+              />
+            </div>
+
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">분류</label>
+              <select
+                value={formData.type}
+                onChange={(e) => setFormData({ ...formData, type: e.target.value as BasePoint['type'] })}
+                className="w-full px-3 py-2 border rounded"
+              >
+                <option value="accommodation">🏨 숙소</option>
+                <option value="airport">✈️ 공항</option>
+                <option value="station">🚉 역/정류장</option>
+                <option value="parking">🅿️ 주차장</option>
+                <option value="other">📍 기타</option>
+              </select>
+            </div>
+
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">주소</label>
+              <input
+                type="text"
+                value={formData.address}
+                onChange={(e) => setFormData({ ...formData, address: e.target.value })}
+                placeholder="849-7 Hikimizu, Ozu, Kikuchi District, Kumamoto 869-1234"
+                className="w-full px-3 py-2 border rounded"
+              />
+            </div>
+
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">위치 선택</label>
+              <p className="text-sm text-gray-600 mb-2">
+                지도를 클릭하여 위치를 선택하세요.
+              </p>
+              {selectedLocation && (
+                <p className="text-xs text-green-600 font-medium">
+                  ✓ 위치 선택됨 (위도: {selectedLocation.lat.toFixed(6)}, 경도: {selectedLocation.lng.toFixed(6)})
+                </p>
+              )}
+            </div>
+
+            <div>
+              <label className="block text-sm font-medium text-gray-700 mb-1">메모 (선택)</label>
+              <textarea
+                value={formData.memo}
+                onChange={(e) => setFormData({ ...formData, memo: e.target.value })}
+                placeholder="추가 정보를 입력하세요"
+                className="w-full px-3 py-2 border rounded"
+                rows={2}
+              />
+            </div>
+
+            <button
+              onClick={addBasePoint}
+              className="w-full px-4 py-2 bg-kumamoto-green text-white rounded hover:bg-opacity-90"
+            >
+              추가하기
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* 저장된 기본 포인트 목록 */}
+      {basePoints.length > 0 && (
+        <div className="mb-4 p-3 bg-purple-50 border border-purple-200 rounded">
+          <h4 className="font-semibold text-gray-800 mb-2 text-sm">저장된 기본 정보</h4>
+          <div className="space-y-2">
+            {basePoints.map((point) => (
+              <div key={point.id} className="flex items-start justify-between bg-white p-2 rounded text-sm">
+                <div className="flex-1">
+                  <div className="font-medium text-gray-800">
+                    {getTypeEmoji(point.type)} {point.name}
+                  </div>
+                  <div className="text-xs text-gray-500">{point.address}</div>
+                  {point.memo && <div className="text-xs text-gray-400 mt-1">{point.memo}</div>}
+                </div>
+                <button
+                  onClick={() => deleteBasePoint(point.id)}
+                  className="text-red-500 hover:text-red-700 text-xs ml-2"
+                >
+                  삭제
+                </button>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+
+      {/* Google Map */}
+      <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200">
+        {!isLoaded && !error && (
+          <div className="w-full h-full flex items-center justify-center bg-gray-100">
+            <div className="text-center">
+              <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-kumamoto-blue mx-auto mb-2"></div>
+              <p className="text-gray-500">Google Maps를 불러오는 중...</p>
+            </div>
+          </div>
+        )}
+        <div id="google-map" className="w-full h-full"></div>
+      </div>
+
+      {/* 마커 설명 */}
+      <div className="mt-4 grid grid-cols-1 md:grid-cols-2 gap-2">
+        <div className="p-3 bg-purple-50 border border-purple-200 rounded text-sm text-purple-800">
+          <strong>🟣 보라색 마커:</strong> 기본 정보 (숙소, 공항, 이동 포인트)
+        </div>
+        <div className="p-3 bg-red-50 border border-red-200 rounded text-sm text-red-800">
+          <strong>🔴 빨간색 마커:</strong> 관광지
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default GoogleMapComponent
diff --git a/src/components/GoogleMapsApiKeyManager.tsx b/src/components/GoogleMapsApiKeyManager.tsx
new file mode 100644
index 0000000..92f6176
--- /dev/null
+++ b/src/components/GoogleMapsApiKeyManager.tsx
@@ -0,0 +1,245 @@
+import { useState, useEffect } from 'react'
+import { 
+  getGoogleMapsApiKey, 
+  setGoogleMapsApiKey, 
+  validateGoogleMapsApiKey, 
+  clearGoogleMapsApiKey, 
+  getApiKeyInfo,
+  maskApiKey 
+} from '../services/apiKeyManager'
+
+interface ApiKeyManagerProps {
+  onApiKeyChange?: (hasValidKey: boolean) => void
+}
+
+const GoogleMapsApiKeyManager = ({ onApiKeyChange }: ApiKeyManagerProps) => {
+  const [apiKey, setApiKey] = useState('')
+  const [isValidating, setIsValidating] = useState(false)
+  const [validationResult, setValidationResult] = useState<{ isValid: boolean; error?: string } | null>(null)
+  const [showApiKey, setShowApiKey] = useState(false)
+  const [apiKeyInfo, setApiKeyInfo] = useState(getApiKeyInfo())
+  const [showManager, setShowManager] = useState(false)
+
+  useEffect(() => {
+    updateApiKeyInfo()
+  }, [])
+
+  const updateApiKeyInfo = () => {
+    const info = getApiKeyInfo()
+    setApiKeyInfo(info)
+    
+    if (onApiKeyChange) {
+      onApiKeyChange(info.hasApiKey && info.isValid)
+    }
+  }
+
+  const handleValidateAndSave = async () => {
+    if (!apiKey.trim()) {
+      setValidationResult({ isValid: false, error: 'API 키를 입력해주세요.' })
+      return
+    }
+
+    setIsValidating(true)
+    setValidationResult(null)
+
+    try {
+      const result = await validateGoogleMapsApiKey(apiKey.trim())
+      setValidationResult(result)
+
+      if (result.isValid) {
+        setGoogleMapsApiKey(apiKey.trim())
+        setApiKey('')
+        updateApiKeyInfo()
+        setShowManager(false)
+      }
+    } catch (error) {
+      setValidationResult({ 
+        isValid: false, 
+        error: `검증 중 오류가 발생했습니다: ${error instanceof Error ? error.message : '알 수 없는 오류'}` 
+      })
+    } finally {
+      setIsValidating(false)
+    }
+  }
+
+  const handleClearApiKey = () => {
+    if (confirm('저장된 API 키를 삭제하시겠습니까?')) {
+      clearGoogleMapsApiKey()
+      setApiKey('')
+      setValidationResult(null)
+      updateApiKeyInfo()
+    }
+  }
+
+  const handleRevalidate = async () => {
+    setIsValidating(true)
+    const result = await validateGoogleMapsApiKey()
+    setValidationResult(result)
+    setIsValidating(false)
+    updateApiKeyInfo()
+  }
+
+  const getStatusColor = () => {
+    if (!apiKeyInfo.hasApiKey) return 'text-gray-600 bg-gray-50 border-gray-200'
+    if (apiKeyInfo.isValid) return 'text-green-600 bg-green-50 border-green-200'
+    return 'text-yellow-600 bg-yellow-50 border-yellow-200'
+  }
+
+  const getStatusIcon = () => {
+    if (!apiKeyInfo.hasApiKey) return '⚙️'
+    if (apiKeyInfo.isValid) return '✅'
+    return '⚠️'
+  }
+
+  const getStatusMessage = () => {
+    if (!apiKeyInfo.hasApiKey) return 'Google Maps API 키가 설정되지 않았습니다'
+    if (apiKeyInfo.isValid) return 'Google Maps API 키가 유효합니다'
+    return 'Google Maps API 키 검증이 필요합니다'
+  }
+
+  return (
+    <div className={`p-3 rounded-lg border text-sm ${getStatusColor()}`}>
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <span className="text-lg">{getStatusIcon()}</span>
+          <span className="font-medium">Google Maps API</span>
+          <button
+            onClick={() => setShowManager(!showManager)}
+            className="text-xs underline opacity-75 hover:opacity-100"
+          >
+            {showManager ? '닫기' : '설정'}
+          </button>
+        </div>
+        
+        <div className="flex items-center gap-2 text-xs">
+          {apiKeyInfo.hasApiKey && (
+            <span>
+              {apiKeyInfo.isFromStorage ? '💾 저장됨' : '🔧 환경변수'}
+            </span>
+          )}
+          {apiKeyInfo.isValid && (
+            <button
+              onClick={handleRevalidate}
+              disabled={isValidating}
+              className="px-2 py-1 bg-white bg-opacity-50 rounded hover:bg-opacity-75 disabled:opacity-50"
+            >
+              {isValidating ? '검증중...' : '재검증'}
+            </button>
+          )}
+        </div>
+      </div>
+
+      <div className="mt-1 text-xs opacity-90">
+        {getStatusMessage()}
+      </div>
+
+      {showManager && (
+        <div className="mt-4 space-y-3 pt-3 border-t border-current border-opacity-20">
+          <div>
+            <label className="block text-xs font-medium mb-2">
+              Google Maps API 키 입력
+            </label>
+            <div className="space-y-2">
+              <div className="flex gap-2">
+                <input
+                  type={showApiKey ? 'text' : 'password'}
+                  value={apiKey}
+                  onChange={(e) => setApiKey(e.target.value)}
+                  placeholder="AIzaSyC..."
+                  className="flex-1 px-3 py-2 border border-current border-opacity-30 rounded text-sm bg-white"
+                  disabled={isValidating}
+                />
+                <button
+                  onClick={() => setShowApiKey(!showApiKey)}
+                  className="px-3 py-2 bg-white bg-opacity-50 rounded hover:bg-opacity-75 text-xs"
+                  type="button"
+                >
+                  {showApiKey ? '🙈' : '👁️'}
+                </button>
+              </div>
+              
+              <div className="flex gap-2">
+                <button
+                  onClick={handleValidateAndSave}
+                  disabled={isValidating || !apiKey.trim()}
+                  className="flex-1 px-3 py-2 bg-current text-white rounded hover:opacity-90 disabled:opacity-50 text-xs font-medium"
+                >
+                  {isValidating ? '검증 중...' : '검증 후 저장'}
+                </button>
+                
+                {apiKeyInfo.hasApiKey && apiKeyInfo.isFromStorage && (
+                  <button
+                    onClick={handleClearApiKey}
+                    className="px-3 py-2 bg-red-500 text-white rounded hover:bg-red-600 text-xs"
+                  >
+                    삭제
+                  </button>
+                )}
+              </div>
+            </div>
+          </div>
+
+          {/* 검증 결과 */}
+          {validationResult && (
+            <div className={`p-2 rounded text-xs ${
+              validationResult.isValid 
+                ? 'bg-green-100 text-green-800 border border-green-200' 
+                : 'bg-red-100 text-red-800 border border-red-200'
+            }`}>
+              {validationResult.isValid ? (
+                <div className="flex items-center gap-1">
+                  <span>✅</span>
+                  <span>API 키가 유효합니다!</span>
+                </div>
+              ) : (
+                <div className="flex items-center gap-1">
+                  <span>❌</span>
+                  <span>{validationResult.error}</span>
+                </div>
+              )}
+            </div>
+          )}
+
+          {/* 현재 API 키 정보 */}
+          {apiKeyInfo.hasApiKey && (
+            <div className="p-2 bg-white bg-opacity-30 rounded text-xs">
+              <div className="font-medium mb-1">현재 설정된 API 키</div>
+              <div className="space-y-1 opacity-75">
+                <div>키: {maskApiKey()}</div>
+                <div>출처: {apiKeyInfo.isFromStorage ? '로컬 저장소' : '환경변수'}</div>
+                {apiKeyInfo.lastUpdated && (
+                  <div>업데이트: {new Date(apiKeyInfo.lastUpdated).toLocaleString()}</div>
+                )}
+                <div>상태: {apiKeyInfo.isValid ? '✅ 유효함' : '⚠️ 검증 필요'}</div>
+              </div>
+            </div>
+          )}
+
+          {/* 도움말 */}
+          <div className="p-2 bg-white bg-opacity-20 rounded text-xs opacity-75">
+            <div className="font-medium mb-1">💡 Google Maps API 키 발급 방법</div>
+            <div className="space-y-1">
+              <div>1. <a href="https://console.cloud.google.com/" target="_blank" rel="noopener noreferrer" className="underline">Google Cloud Console</a>에 접속</div>
+              <div>2. 프로젝트 생성 또는 선택</div>
+              <div>3. "API 및 서비스" → "사용자 인증 정보"</div>
+              <div>4. "사용자 인증 정보 만들기" → "API 키"</div>
+              <div>5. Maps JavaScript API 활성화</div>
+            </div>
+          </div>
+
+          {/* 무료 한도 정보 */}
+          <div className="p-2 bg-white bg-opacity-20 rounded text-xs opacity-75">
+            <div className="font-medium mb-1">📊 무료 사용 한도</div>
+            <div className="space-y-1">
+              <div>• Maps JavaScript API: 월 28,000 요청</div>
+              <div>• 일반적인 개인 사용에는 충분함</div>
+              <div>• 사용량은 자동으로 모니터링됨</div>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default GoogleMapsApiKeyManager
diff --git a/src/components/GoogleMapsUsageIndicator.tsx b/src/components/GoogleMapsUsageIndicator.tsx
new file mode 100644
index 0000000..0a65d86
--- /dev/null
+++ b/src/components/GoogleMapsUsageIndicator.tsx
@@ -0,0 +1,179 @@
+import { useEffect, useState } from 'react'
+import { getGoogleMapsUsage, getGoogleMapsWarningLevel, resetGoogleMapsUsage } from '../services/googleMapsUsage'
+
+interface UsageIndicatorProps {
+  onUsageExceeded?: () => void
+}
+
+const GoogleMapsUsageIndicator = ({ onUsageExceeded }: UsageIndicatorProps) => {
+  const [usage, setUsage] = useState<any>(null)
+  const [warningLevel, setWarningLevel] = useState<'safe' | 'warning' | 'danger' | 'blocked'>('safe')
+  const [showDetails, setShowDetails] = useState(false)
+
+  useEffect(() => {
+    updateUsage()
+    
+    // 1분마다 사용량 업데이트
+    const interval = setInterval(updateUsage, 60000)
+    return () => clearInterval(interval)
+  }, [])
+
+  const updateUsage = () => {
+    const currentUsage = getGoogleMapsUsage()
+    const currentWarningLevel = getGoogleMapsWarningLevel()
+    
+    setUsage(currentUsage)
+    setWarningLevel(currentWarningLevel)
+
+    // 사용량 초과 시 콜백 호출
+    if (currentWarningLevel === 'blocked' && onUsageExceeded) {
+      onUsageExceeded()
+    }
+  }
+
+  const getWarningColor = (level: string) => {
+    switch (level) {
+      case 'safe': return 'text-green-600 bg-green-50 border-green-200'
+      case 'warning': return 'text-yellow-600 bg-yellow-50 border-yellow-200'
+      case 'danger': return 'text-orange-600 bg-orange-50 border-orange-200'
+      case 'blocked': return 'text-red-600 bg-red-50 border-red-200'
+      default: return 'text-gray-600 bg-gray-50 border-gray-200'
+    }
+  }
+
+  const getWarningIcon = (level: string) => {
+    switch (level) {
+      case 'safe': return '✅'
+      case 'warning': return '⚠️'
+      case 'danger': return '🚨'
+      case 'blocked': return '🚫'
+      default: return 'ℹ️'
+    }
+  }
+
+  const getWarningMessage = (level: string) => {
+    switch (level) {
+      case 'safe': return '구글 맵 사용량이 안전합니다'
+      case 'warning': return '구글 맵 사용량이 70%를 초과했습니다'
+      case 'danger': return '구글 맵 사용량이 90%를 초과했습니다'
+      case 'blocked': return '구글 맵 사용량 한도를 초과했습니다'
+      default: return '사용량을 확인할 수 없습니다'
+    }
+  }
+
+  const handleReset = () => {
+    if (confirm('구글 맵 사용량을 초기화하시겠습니까? (개발/테스트 목적으로만 사용하세요)')) {
+      resetGoogleMapsUsage()
+      updateUsage()
+    }
+  }
+
+  if (!usage) {
+    return null
+  }
+
+  return (
+    <div className={`p-3 rounded-lg border text-sm ${getWarningColor(warningLevel)}`}>
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2">
+          <span className="text-lg">{getWarningIcon(warningLevel)}</span>
+          <span className="font-medium">구글 맵 사용량</span>
+          <button
+            onClick={() => setShowDetails(!showDetails)}
+            className="text-xs underline opacity-75 hover:opacity-100"
+          >
+            {showDetails ? '숨기기' : '자세히'}
+          </button>
+        </div>
+        
+        <div className="flex items-center gap-2">
+          <span className="text-xs">
+            일일: {usage.daily.current}/{usage.daily.limit}
+          </span>
+          {import.meta.env.DEV && (
+            <button
+              onClick={handleReset}
+              className="text-xs px-2 py-1 bg-white bg-opacity-50 rounded hover:bg-opacity-75"
+              title="개발용: 사용량 초기화"
+            >
+              리셋
+            </button>
+          )}
+        </div>
+      </div>
+
+      <div className="mt-1 text-xs opacity-90">
+        {getWarningMessage(warningLevel)}
+      </div>
+
+      {showDetails && (
+        <div className="mt-3 space-y-2 text-xs">
+          <div className="grid grid-cols-3 gap-4">
+            {/* 시간당 사용량 */}
+            <div>
+              <div className="font-medium mb-1">시간당</div>
+              <div className="flex items-center gap-2">
+                <div className="flex-1 bg-white bg-opacity-50 rounded-full h-2">
+                  <div 
+                    className="h-full bg-current rounded-full transition-all"
+                    style={{ width: `${Math.min(usage.hourly.percentage, 100)}%` }}
+                  />
+                </div>
+                <span>{usage.hourly.current}/{usage.hourly.limit}</span>
+              </div>
+              <div className="mt-1 opacity-75">{usage.hourly.percentage}%</div>
+            </div>
+
+            {/* 일일 사용량 */}
+            <div>
+              <div className="font-medium mb-1">일일</div>
+              <div className="flex items-center gap-2">
+                <div className="flex-1 bg-white bg-opacity-50 rounded-full h-2">
+                  <div 
+                    className="h-full bg-current rounded-full transition-all"
+                    style={{ width: `${Math.min(usage.daily.percentage, 100)}%` }}
+                  />
+                </div>
+                <span>{usage.daily.current}/{usage.daily.limit}</span>
+              </div>
+              <div className="mt-1 opacity-75">{usage.daily.percentage}%</div>
+            </div>
+
+            {/* 월간 사용량 */}
+            <div>
+              <div className="font-medium mb-1">월간</div>
+              <div className="flex items-center gap-2">
+                <div className="flex-1 bg-white bg-opacity-50 rounded-full h-2">
+                  <div 
+                    className="h-full bg-current rounded-full transition-all"
+                    style={{ width: `${Math.min(usage.monthly.percentage, 100)}%` }}
+                  />
+                </div>
+                <span>{usage.monthly.current}/{usage.monthly.limit}</span>
+              </div>
+              <div className="mt-1 opacity-75">{usage.monthly.percentage}%</div>
+            </div>
+          </div>
+
+          <div className="pt-2 border-t border-current border-opacity-20">
+            <div className="flex justify-between items-center">
+              <span>마지막 리셋: {usage.lastReset}</span>
+              <span className="opacity-75">
+                {warningLevel === 'blocked' ? '🚫 사용 차단됨' : '✅ 사용 가능'}
+              </span>
+            </div>
+          </div>
+
+          <div className="pt-2 border-t border-current border-opacity-20 text-xs opacity-75">
+            <div>💡 <strong>무료 한도 정보:</strong></div>
+            <div>• Google Maps JavaScript API: 월 28,000 요청</div>
+            <div>• 안전 마진 20% 적용하여 22,400 요청으로 제한</div>
+            <div>• 시간당 30회, 일일 750회 제한</div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default GoogleMapsUsageIndicator
diff --git a/src/components/Header.tsx b/src/components/Header.tsx
index fa44836..64a9609 100644
--- a/src/components/Header.tsx
+++ b/src/components/Header.tsx
@@ -10,9 +10,9 @@ const Header = () => {
       />
       <div className="relative container mx-auto px-4 py-6">
         <div className="flex items-center justify-between">
-          <h1 className="text-2xl font-bold">🇯🇵 구마모토 여행</h1>
+          <h1 className="text-2xl font-bold">✈️ Travel Planner</h1>
           <div className="text-sm opacity-90">
-            가족과 함께하는 여행 계획
+            스마트한 여행 계획 관리 시스템
           </div>
         </div>
       </div>
diff --git a/src/components/InitialSetup.tsx b/src/components/InitialSetup.tsx
new file mode 100644
index 0000000..07aa1f9
--- /dev/null
+++ b/src/components/InitialSetup.tsx
@@ -0,0 +1,429 @@
+import { useState, useEffect } from 'react'
+import { initialSetupService, InitialSetupData, SetupStatus } from '../services/initialSetup'
+
+interface InitialSetupProps {
+  onSetupComplete: () => void
+  className?: string
+}
+
+const InitialSetup = ({ onSetupComplete, className = '' }: InitialSetupProps) => {
+  const [setupStatus, setSetupStatus] = useState<SetupStatus | null>(null)
+  const [currentStep, setCurrentStep] = useState(1)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [isSubmitting, setIsSubmitting] = useState(false)
+
+  const [setupData, setSetupData] = useState<InitialSetupData>({
+    admin_name: '',
+    admin_email: '',
+    admin_password: '',
+    site_name: 'Travel Planner',
+    site_description: '스마트한 여행 계획 도구',
+    default_language: 'ko',
+    default_currency: 'KRW'
+  })
+
+  const [envCheck, setEnvCheck] = useState({
+    database_url: false,
+    jwt_secret: false,
+    google_maps_key: false,
+    email_config: false
+  })
+
+  useEffect(() => {
+    checkInitialStatus()
+  }, [])
+
+  const checkInitialStatus = async () => {
+    try {
+      setIsLoading(true)
+      const status = await initialSetupService.checkSetupStatus()
+      setSetupStatus(status)
+
+      if (!status.is_setup_required) {
+        onSetupComplete()
+        return
+      }
+
+      // 환경 변수 확인
+      const env = await initialSetupService.checkEnvironment()
+      setEnvCheck(env)
+    } catch (error) {
+      setError('초기 상태 확인 중 오류가 발생했습니다')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+    setError(null)
+
+    try {
+      const result = await initialSetupService.performInitialSetup(setupData)
+      
+      if (result.success) {
+        alert('초기 설정이 완료되었습니다! 관리자 계정으로 로그인해주세요.')
+        onSetupComplete()
+      } else {
+        setError(result.message)
+      }
+    } catch (error) {
+      setError('초기 설정 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  const testDatabaseConnection = async () => {
+    try {
+      const result = await initialSetupService.testDatabaseConnection()
+      if (result.success) {
+        alert('✅ 데이터베이스 연결 성공!')
+      } else {
+        alert(`❌ 데이터베이스 연결 실패: ${result.message}`)
+      }
+    } catch (error) {
+      alert('❌ 데이터베이스 연결 테스트 중 오류가 발생했습니다')
+    }
+  }
+
+  if (isLoading) {
+    return (
+      <div className={`min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 flex items-center justify-center ${className}`}>
+        <div className="bg-white rounded-lg shadow-lg p-8 w-full max-w-md">
+          <div className="text-center">
+            <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
+            <div className="text-lg font-medium text-gray-800">시스템 상태 확인 중...</div>
+            <div className="text-sm text-gray-600 mt-2">잠시만 기다려주세요</div>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className={`min-h-screen bg-gradient-to-br from-blue-50 to-indigo-100 flex items-center justify-center p-4 ${className}`}>
+      <div className="bg-white rounded-lg shadow-xl p-8 w-full max-w-2xl">
+        {/* 헤더 */}
+        <div className="text-center mb-8">
+          <div className="text-6xl mb-4">🚀</div>
+          <h1 className="text-3xl font-bold text-gray-800 mb-2">
+            Travel Planner 초기 설정
+          </h1>
+          <p className="text-gray-600">
+            서버를 처음 실행하시는군요! 관리자 계정과 기본 설정을 구성해주세요.
+          </p>
+        </div>
+
+        {/* 진행 단계 */}
+        <div className="mb-8">
+          <div className="flex items-center justify-between mb-4">
+            {[1, 2, 3].map((step) => (
+              <div key={step} className="flex items-center">
+                <div className={`w-8 h-8 rounded-full flex items-center justify-center text-sm font-medium ${
+                  currentStep >= step 
+                    ? 'bg-blue-600 text-white' 
+                    : 'bg-gray-200 text-gray-600'
+                }`}>
+                  {step}
+                </div>
+                {step < 3 && (
+                  <div className={`w-16 h-1 mx-2 ${
+                    currentStep > step ? 'bg-blue-600' : 'bg-gray-200'
+                  }`} />
+                )}
+              </div>
+            ))}
+          </div>
+          <div className="flex justify-between text-sm text-gray-600">
+            <span>환경 확인</span>
+            <span>관리자 계정</span>
+            <span>사이트 설정</span>
+          </div>
+        </div>
+
+        {/* 에러 메시지 */}
+        {error && (
+          <div className="mb-6 p-4 bg-red-50 border border-red-200 rounded-lg">
+            <div className="flex items-center gap-2 text-red-700">
+              <span>⚠️</span>
+              <span className="text-sm">{error}</span>
+            </div>
+          </div>
+        )}
+
+        {/* 단계별 내용 */}
+        {currentStep === 1 && (
+          <div className="space-y-6">
+            <h2 className="text-xl font-semibold text-gray-800">1. 환경 설정 확인</h2>
+            
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <div className={`p-4 rounded-lg border ${envCheck.database_url ? 'bg-green-50 border-green-200' : 'bg-red-50 border-red-200'}`}>
+                <div className="flex items-center justify-between">
+                  <span className="font-medium">데이터베이스</span>
+                  <span className={envCheck.database_url ? 'text-green-600' : 'text-red-600'}>
+                    {envCheck.database_url ? '✅' : '❌'}
+                  </span>
+                </div>
+                <div className="text-sm text-gray-600 mt-1">
+                  {envCheck.database_url ? '연결 가능' : 'DATABASE_URL 설정 필요'}
+                </div>
+              </div>
+
+              <div className={`p-4 rounded-lg border ${envCheck.jwt_secret ? 'bg-green-50 border-green-200' : 'bg-red-50 border-red-200'}`}>
+                <div className="flex items-center justify-between">
+                  <span className="font-medium">JWT 시크릿</span>
+                  <span className={envCheck.jwt_secret ? 'text-green-600' : 'text-red-600'}>
+                    {envCheck.jwt_secret ? '✅' : '❌'}
+                  </span>
+                </div>
+                <div className="text-sm text-gray-600 mt-1">
+                  {envCheck.jwt_secret ? '설정됨' : 'JWT_SECRET 설정 필요'}
+                </div>
+              </div>
+
+              <div className={`p-4 rounded-lg border ${envCheck.google_maps_key ? 'bg-green-50 border-green-200' : 'bg-yellow-50 border-yellow-200'}`}>
+                <div className="flex items-center justify-between">
+                  <span className="font-medium">Google Maps</span>
+                  <span className={envCheck.google_maps_key ? 'text-green-600' : 'text-yellow-600'}>
+                    {envCheck.google_maps_key ? '✅' : '⚠️'}
+                  </span>
+                </div>
+                <div className="text-sm text-gray-600 mt-1">
+                  {envCheck.google_maps_key ? '설정됨' : '선택사항 (나중에 설정 가능)'}
+                </div>
+              </div>
+
+              <div className={`p-4 rounded-lg border ${envCheck.email_config ? 'bg-green-50 border-green-200' : 'bg-yellow-50 border-yellow-200'}`}>
+                <div className="flex items-center justify-between">
+                  <span className="font-medium">이메일 설정</span>
+                  <span className={envCheck.email_config ? 'text-green-600' : 'text-yellow-600'}>
+                    {envCheck.email_config ? '✅' : '⚠️'}
+                  </span>
+                </div>
+                <div className="text-sm text-gray-600 mt-1">
+                  {envCheck.email_config ? '설정됨' : '선택사항 (알림 기능용)'}
+                </div>
+              </div>
+            </div>
+
+            <div className="flex gap-2">
+              <button
+                onClick={testDatabaseConnection}
+                className="px-4 py-2 bg-blue-100 text-blue-700 rounded hover:bg-blue-200"
+              >
+                🔍 DB 연결 테스트
+              </button>
+            </div>
+
+            <div className="flex justify-end">
+              <button
+                onClick={() => setCurrentStep(2)}
+                disabled={!envCheck.database_url || !envCheck.jwt_secret}
+                className="px-6 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                다음 단계 →
+              </button>
+            </div>
+          </div>
+        )}
+
+        {currentStep === 2 && (
+          <div className="space-y-6">
+            <h2 className="text-xl font-semibold text-gray-800">2. 관리자 계정 생성</h2>
+            
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  관리자 이름 *
+                </label>
+                <input
+                  type="text"
+                  value={setupData.admin_name}
+                  onChange={(e) => setSetupData({ ...setupData, admin_name: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="홍길동"
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  관리자 이메일 *
+                </label>
+                <input
+                  type="email"
+                  value={setupData.admin_email}
+                  onChange={(e) => setSetupData({ ...setupData, admin_email: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="admin@example.com"
+                  required
+                />
+              </div>
+
+              <div className="md:col-span-2">
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  관리자 비밀번호 *
+                </label>
+                <input
+                  type="password"
+                  value={setupData.admin_password}
+                  onChange={(e) => setSetupData({ ...setupData, admin_password: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="8자 이상의 안전한 비밀번호"
+                  required
+                  minLength={8}
+                />
+                <div className="text-xs text-gray-500 mt-1">
+                  ⚠️ 이 계정으로 모든 사용자와 시스템을 관리할 수 있습니다. 안전한 비밀번호를 사용하세요.
+                </div>
+              </div>
+            </div>
+
+            <div className="flex justify-between">
+              <button
+                onClick={() => setCurrentStep(1)}
+                className="px-6 py-2 border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+              >
+                ← 이전 단계
+              </button>
+              <button
+                onClick={() => setCurrentStep(3)}
+                disabled={!setupData.admin_name || !setupData.admin_email || !setupData.admin_password}
+                className="px-6 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50 disabled:cursor-not-allowed"
+              >
+                다음 단계 →
+              </button>
+            </div>
+          </div>
+        )}
+
+        {currentStep === 3 && (
+          <div className="space-y-6">
+            <h2 className="text-xl font-semibold text-gray-800">3. 사이트 기본 설정</h2>
+            
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  사이트 이름
+                </label>
+                <input
+                  type="text"
+                  value={setupData.site_name}
+                  onChange={(e) => setSetupData({ ...setupData, site_name: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="Travel Planner"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  기본 언어
+                </label>
+                <select
+                  value={setupData.default_language}
+                  onChange={(e) => setSetupData({ ...setupData, default_language: e.target.value as any })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                >
+                  <option value="ko">🇰🇷 한국어</option>
+                  <option value="en">🇺🇸 English</option>
+                  <option value="ja">🇯🇵 日本語</option>
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  기본 통화
+                </label>
+                <select
+                  value={setupData.default_currency}
+                  onChange={(e) => setSetupData({ ...setupData, default_currency: e.target.value as any })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                >
+                  <option value="KRW">₩ 원 (KRW)</option>
+                  <option value="JPY">¥ 엔 (JPY)</option>
+                  <option value="USD">$ 달러 (USD)</option>
+                </select>
+              </div>
+
+              <div className="md:col-span-2">
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  사이트 설명 (선택사항)
+                </label>
+                <textarea
+                  value={setupData.site_description}
+                  onChange={(e) => setSetupData({ ...setupData, site_description: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  rows={3}
+                  placeholder="스마트한 여행 계획 도구"
+                />
+              </div>
+            </div>
+
+            <div className="bg-blue-50 border border-blue-200 rounded-lg p-4">
+              <h3 className="font-medium text-blue-800 mb-2">📋 설정 요약</h3>
+              <div className="text-sm text-blue-700 space-y-1">
+                <div>• 관리자: {setupData.admin_name} ({setupData.admin_email})</div>
+                <div>• 사이트: {setupData.site_name}</div>
+                <div>• 언어: {setupData.default_language === 'ko' ? '한국어' : setupData.default_language === 'en' ? 'English' : '日本語'}</div>
+                <div>• 통화: {setupData.default_currency}</div>
+              </div>
+            </div>
+
+            <form onSubmit={handleSubmit}>
+              <div className="flex justify-between">
+                <button
+                  type="button"
+                  onClick={() => setCurrentStep(2)}
+                  className="px-6 py-2 border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+                >
+                  ← 이전 단계
+                </button>
+                <button
+                  type="submit"
+                  disabled={isSubmitting}
+                  className="px-8 py-2 bg-green-600 text-white rounded hover:bg-green-700 disabled:opacity-50 disabled:cursor-not-allowed"
+                >
+                  {isSubmitting ? (
+                    <div className="flex items-center gap-2">
+                      <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                      설정 중...
+                    </div>
+                  ) : (
+                    '🚀 설정 완료'
+                  )}
+                </button>
+              </div>
+            </form>
+          </div>
+        )}
+
+        {/* 개발 환경 안내 */}
+        {import.meta.env.DEV && (
+          <div className="mt-8 p-4 bg-yellow-50 border border-yellow-200 rounded-lg">
+            <div className="text-sm text-yellow-800">
+              <div className="font-medium mb-1">🛠️ 개발 환경</div>
+              <div>• 데이터는 브라우저 로컬 스토리지에 저장됩니다</div>
+              <div>• 실제 서버에서는 데이터베이스를 사용합니다</div>
+              <button
+                onClick={() => {
+                  if (confirm('모든 설정을 초기화하시겠습니까?')) {
+                    initialSetupService.resetSetup()
+                    window.location.reload()
+                  }
+                }}
+                className="mt-2 text-xs text-yellow-700 hover:text-yellow-900 underline"
+              >
+                설정 초기화
+              </button>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+export default InitialSetup
diff --git a/src/components/LeafletMapComponent.tsx b/src/components/LeafletMapComponent.tsx
new file mode 100644
index 0000000..ea69f2e
--- /dev/null
+++ b/src/components/LeafletMapComponent.tsx
@@ -0,0 +1,561 @@
+import { useEffect, useState } from 'react'
+import { MapContainer, TileLayer, Marker, Popup } from 'react-leaflet'
+import { Icon } from 'leaflet'
+import { Attraction, BasePoint } from '../types'
+import { basePointsAPI } from '../services/api'
+import 'leaflet/dist/leaflet.css'
+
+interface LeafletMapComponentProps {
+  attractions: Attraction[]
+  basePoints: BasePoint[]
+  onBasePointsUpdate?: (basePoints: BasePoint[]) => void
+  selectedActivityId?: string
+  currentDaySchedule?: any
+  onActivityClick?: (activity: any) => void
+  getActivityCoords?: (activity: any) => [number, number] | null
+}
+
+interface SearchResult {
+  display_name: string
+  lat: string
+  lon: string
+}
+
+const LeafletMapComponent = ({ 
+  attractions, 
+  basePoints, 
+  onBasePointsUpdate,
+  selectedActivityId,
+  currentDaySchedule,
+  onActivityClick,
+  getActivityCoords
+}: LeafletMapComponentProps) => {
+  const [isMounted, setIsMounted] = useState(false)
+  const [mapError, setMapError] = useState<string | null>(null)
+  const [showAddForm, setShowAddForm] = useState(false)
+
+  // 폼 상태
+  const [formData, setFormData] = useState({
+    name: '',
+    address: '',
+    type: 'accommodation' as BasePoint['type'],
+    memo: ''
+  })
+
+  const [searchResults, setSearchResults] = useState<SearchResult[]>([])
+  const [isSearching, setIsSearching] = useState(false)
+  const [selectedLocation, setSelectedLocation] = useState<{ lat: number; lng: number } | null>(null)
+
+  useEffect(() => {
+    // 클라이언트에서만 실행
+    if (typeof window !== 'undefined') {
+      setIsMounted(true)
+    }
+  }, [])
+
+  // 주소 검색 (Nominatim API)
+  const searchAddress = async (query: string) => {
+    if (!query.trim()) return
+
+    setIsSearching(true)
+    try {
+      // 구마모토 지역에 검색 제한
+      const response = await fetch(
+        `https://nominatim.openstreetmap.org/search?` +
+        `q=${encodeURIComponent(query + ' 熊本')}&` +
+        `format=json&` +
+        `limit=5&` +
+        `countrycodes=jp&` +
+        `accept-language=ja`
+      )
+      const data = await response.json()
+      setSearchResults(data)
+    } catch (error) {
+      console.error('Address search failed:', error)
+      alert('주소 검색에 실패했습니다.')
+    } finally {
+      setIsSearching(false)
+    }
+  }
+
+  // 검색 결과 선택
+  const selectSearchResult = (result: SearchResult) => {
+    setSelectedLocation({
+      lat: parseFloat(result.lat),
+      lng: parseFloat(result.lon)
+    })
+    setFormData({ ...formData, address: result.display_name })
+    setSearchResults([])
+  }
+
+  // 기본 포인트 추가
+  const addBasePoint = async () => {
+    if (!formData.name || !formData.address || !selectedLocation) {
+      alert('이름과 주소를 입력하고 검색 결과에서 선택해주세요.')
+      return
+    }
+
+    try {
+      const newPoint = await basePointsAPI.create({
+        name: formData.name,
+        address: formData.address,
+        type: formData.type,
+        coordinates: selectedLocation,
+        memo: formData.memo || undefined
+      })
+
+      const updatedBasePoints = [...basePoints, newPoint]
+      onBasePointsUpdate(updatedBasePoints)
+
+      // 폼 초기화
+      setFormData({
+        name: '',
+        address: '',
+        type: 'accommodation',
+        memo: ''
+      })
+      setSelectedLocation(null)
+      setShowAddForm(false)
+    } catch (error) {
+      console.error('Failed to add base point:', error)
+      alert('기본 포인트 추가에 실패했습니다.')
+    }
+  }
+
+  // 기본 포인트 삭제
+  const deleteBasePoint = async (id: string) => {
+    if (confirm('이 위치를 삭제하시겠습니까?')) {
+      try {
+        await basePointsAPI.delete(id)
+        const updatedBasePoints = basePoints.filter(p => p.id !== id)
+        onBasePointsUpdate(updatedBasePoints)
+      } catch (error) {
+        console.error('Failed to delete base point:', error)
+        alert('기본 포인트 삭제에 실패했습니다.')
+      }
+    }
+  }
+
+  // 구마모토 중심 좌표
+  const kumamotoCenter: [number, number] = [32.8031, 130.7079]
+
+  // 타일 서버 URL
+  const tilesUrl = import.meta.env.VITE_MAP_TILES_URL || 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'
+  const isCustomTiles = !!import.meta.env.VITE_MAP_TILES_URL
+
+  // 타입별 아이콘 색상
+  const getTypeEmoji = (type: BasePoint['type']) => {
+    switch (type) {
+      case 'accommodation': return '🏨'
+      case 'airport': return '✈️'
+      case 'station': return '🚉'
+      case 'parking': return '🅿️'
+      default: return '📍'
+    }
+  }
+
+  const getTypeName = (type: BasePoint['type']) => {
+    switch (type) {
+      case 'accommodation': return '숙소'
+      case 'airport': return '공항'
+      case 'station': return '역/정류장'
+      case 'parking': return '주차장'
+      default: return '기타'
+    }
+  }
+
+  // 마커 아이콘 설정
+  const attractionIcon = new Icon({
+    iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-2x-red.png',
+    shadowUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.7/images/marker-shadow.png',
+    iconSize: [25, 41],
+    iconAnchor: [12, 41],
+    popupAnchor: [1, -34],
+    shadowSize: [41, 41]
+  })
+
+  const basePointIcon = new Icon({
+    iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-2x-violet.png',
+    shadowUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.7/images/marker-shadow.png',
+    iconSize: [25, 41],
+    iconAnchor: [12, 41],
+    popupAnchor: [1, -34],
+    shadowSize: [41, 41]
+  })
+
+  // 서버 사이드에서는 로딩 화면 표시
+  if (!isMounted) {
+    return (
+      <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-gray-100">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-kumamoto-blue mx-auto mb-2"></div>
+          <p className="text-gray-500">지도를 불러오는 중...</p>
+        </div>
+      </div>
+    )
+  }
+
+  // 에러 발생 시
+  if (mapError) {
+    return (
+      <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-red-50">
+        <div className="text-center">
+          <p className="text-red-500 mb-2">⚠️ {mapError}</p>
+          <button
+            onClick={() => {
+              setMapError(null)
+              window.location.reload()
+            }}
+            className="px-4 py-2 bg-red-500 text-white rounded hover:bg-red-600"
+          >
+            새로고침
+          </button>
+        </div>
+      </div>
+    )
+  }
+
+  // 클라이언트에서 렌더링
+  try {
+    return (
+      <div>
+        {/* 기본 정보 추가 버튼 */}
+        <div className="mb-4 flex justify-end">
+          <button
+            onClick={() => setShowAddForm(!showAddForm)}
+            className="px-4 py-2 bg-kumamoto-primary text-white rounded hover:bg-kumamoto-secondary transition-colors"
+          >
+            {showAddForm ? '닫기' : '+ 기본 정보 추가'}
+          </button>
+        </div>
+
+        {/* 기본 정보 추가 폼 */}
+        {showAddForm && (
+          <div className="mb-6 p-4 bg-gray-50 rounded-lg border border-gray-200">
+            <h3 className="font-semibold text-gray-800 mb-4">기본 정보 추가 (숙소, 공항, 이동 포인트)</h3>
+
+            <div className="space-y-3">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">이름</label>
+                <input
+                  type="text"
+                  value={formData.name}
+                  onChange={(e) => setFormData({ ...formData, name: e.target.value })}
+                  placeholder="예: 호텔 이름, 구마모토 공항 등"
+                  className="w-full px-3 py-2 border rounded"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">분류</label>
+                <select
+                  value={formData.type}
+                  onChange={(e) => setFormData({ ...formData, type: e.target.value as BasePoint['type'] })}
+                  className="w-full px-3 py-2 border rounded"
+                >
+                  <option value="accommodation">🏨 숙소</option>
+                  <option value="airport">✈️ 공항</option>
+                  <option value="station">🚉 역/정류장</option>
+                  <option value="parking">🅿️ 주차장</option>
+                  <option value="other">📍 기타</option>
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">주소</label>
+                <input
+                  type="text"
+                  value={formData.address}
+                  onChange={(e) => setFormData({ ...formData, address: e.target.value })}
+                  placeholder="849-7 Hikimizu, Ozu, Kikuchi District, Kumamoto 869-1234"
+                  className="w-full px-3 py-2 border rounded"
+                />
+                <p className="text-xs text-gray-500 mt-1">
+                  주소를 직접 입력하세요 (영어, 한글, 일본어 모두 가능)
+                </p>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">위치 좌표 설정</label>
+
+                {/* 옵션 1: 간단한 검색으로 좌표 찾기 */}
+                <div className="mb-3 p-3 bg-blue-50 rounded border border-blue-200">
+                  <p className="text-xs font-medium text-gray-700 mb-2">옵션 1: 간단한 검색으로 좌표 찾기</p>
+                  <div className="flex gap-2">
+                    <input
+                      type="text"
+                      placeholder="간단한 키워드 입력 (예: 구마모토 공항, 오즈 등)"
+                      className="flex-1 px-3 py-2 border rounded text-sm"
+                      onKeyDown={(e) => {
+                        if (e.key === 'Enter') {
+                          searchAddress(e.currentTarget.value)
+                        }
+                      }}
+                    />
+                    <button
+                      onClick={(e) => {
+                        const input = e.currentTarget.previousElementSibling as HTMLInputElement
+                        searchAddress(input.value)
+                      }}
+                      disabled={isSearching}
+                      className="px-3 py-2 bg-kumamoto-blue text-white rounded hover:bg-opacity-90 disabled:bg-gray-400 text-sm"
+                    >
+                      {isSearching ? '검색중...' : '검색'}
+                    </button>
+                  </div>
+
+                  {/* 검색 결과 */}
+                  {searchResults.length > 0 && (
+                    <div className="mt-2 border rounded max-h-40 overflow-y-auto bg-white">
+                      {searchResults.map((result, idx) => (
+                        <button
+                          key={idx}
+                          onClick={() => selectSearchResult(result)}
+                          className="w-full text-left px-3 py-2 hover:bg-gray-100 border-b last:border-b-0 text-xs"
+                        >
+                          <div className="font-medium text-gray-800">결과 {idx + 1}</div>
+                          <div className="text-gray-600 truncate">{result.display_name}</div>
+                          <div className="text-gray-400 text-xs">
+                            위도: {parseFloat(result.lat).toFixed(4)}, 경도: {parseFloat(result.lon).toFixed(4)}
+                          </div>
+                        </button>
+                      ))}
+                    </div>
+                  )}
+                </div>
+
+                {/* 옵션 2: 좌표 직접 입력 */}
+                <div className="p-3 bg-green-50 rounded border border-green-200">
+                  <p className="text-xs font-medium text-gray-700 mb-2">옵션 2: 좌표 직접 입력 (Google Maps에서 확인)</p>
+                  <div className="grid grid-cols-2 gap-2">
+                    <div>
+                      <input
+                        type="number"
+                        step="0.0001"
+                        placeholder="위도 (예: 32.8031)"
+                        className="w-full px-3 py-2 border rounded text-sm"
+                        value={selectedLocation?.lat || ''}
+                        onChange={(e) => {
+                          const lat = parseFloat(e.target.value)
+                          if (!isNaN(lat)) {
+                            setSelectedLocation({
+                              lat,
+                              lng: selectedLocation?.lng || 0
+                            })
+                          }
+                        }}
+                      />
+                    </div>
+                    <div>
+                      <input
+                        type="number"
+                        step="0.0001"
+                        placeholder="경도 (예: 130.7079)"
+                        className="w-full px-3 py-2 border rounded text-sm"
+                        value={selectedLocation?.lng || ''}
+                        onChange={(e) => {
+                          const lng = parseFloat(e.target.value)
+                          if (!isNaN(lng)) {
+                            setSelectedLocation({
+                              lat: selectedLocation?.lat || 0,
+                              lng
+                            })
+                          }
+                        }}
+                      />
+                    </div>
+                  </div>
+                  <p className="text-xs text-gray-500 mt-1">
+                    💡 Google Maps에서 장소 우클릭 → 첫 번째 숫자 복사
+                  </p>
+                </div>
+
+                {selectedLocation && selectedLocation.lat !== 0 && selectedLocation.lng !== 0 && (
+                  <p className="mt-2 text-xs text-green-600 font-medium">
+                    ✓ 위치 선택됨 (위도: {selectedLocation.lat.toFixed(6)}, 경도: {selectedLocation.lng.toFixed(6)})
+                  </p>
+                )}
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">메모 (선택)</label>
+                <textarea
+                  value={formData.memo}
+                  onChange={(e) => setFormData({ ...formData, memo: e.target.value })}
+                  placeholder="추가 정보를 입력하세요"
+                  className="w-full px-3 py-2 border rounded"
+                  rows={2}
+                />
+              </div>
+
+              <button
+                onClick={addBasePoint}
+                className="w-full px-4 py-2 bg-kumamoto-green text-white rounded hover:bg-opacity-90"
+              >
+                추가하기
+              </button>
+            </div>
+          </div>
+        )}
+
+        {/* 저장된 기본 포인트 목록 */}
+        {basePoints.length > 0 && (
+          <div className="mb-4 p-3 bg-purple-50 border border-purple-200 rounded">
+            <h4 className="font-semibold text-gray-800 mb-2 text-sm">저장된 기본 정보</h4>
+            <div className="space-y-2">
+              {basePoints.map((point) => (
+                <div key={point.id} className="flex items-start justify-between bg-white p-2 rounded text-sm">
+                  <div className="flex-1">
+                    <div className="font-medium text-gray-800">
+                      {getTypeEmoji(point.type)} {point.name}
+                    </div>
+                    <div className="text-xs text-gray-500">{point.address}</div>
+                    {point.memo && <div className="text-xs text-gray-400 mt-1">{point.memo}</div>}
+                  </div>
+                  <button
+                    onClick={() => deleteBasePoint(point.id)}
+                    className="text-red-500 hover:text-red-700 text-xs ml-2"
+                  >
+                    삭제
+                  </button>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200">
+          <MapContainer
+            center={kumamotoCenter}
+            zoom={10}
+            style={{ height: '100%', width: '100%' }}
+            className="rounded-lg"
+          >
+            <TileLayer
+              url={tilesUrl}
+              attribution={
+                isCustomTiles
+                  ? '&copy; 구마모토 여행 지도 | OpenStreetMap contributors'
+                  : '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+              }
+              maxZoom={18}
+            />
+
+            {/* 기본 포인트 마커 (보라색) */}
+            {basePoints.map((point) => (
+              <Marker
+                key={point.id}
+                position={[point.coordinates.lat, point.coordinates.lng]}
+                icon={basePointIcon}
+              >
+                <Popup>
+                  <div className="p-2 max-w-xs">
+                    <h3 className="font-bold text-gray-800 mb-2 text-base">
+                      {getTypeEmoji(point.type)} {point.name}
+                    </h3>
+                    <p className="text-xs text-gray-500 mb-1">
+                      <span className="inline-block px-2 py-0.5 bg-purple-100 rounded">
+                        {getTypeName(point.type)}
+                      </span>
+                    </p>
+                    <p className="text-gray-600 text-sm mb-2">
+                      📍 {point.address}
+                    </p>
+                    {point.memo && (
+                      <p className="text-gray-500 text-xs">
+                        📝 {point.memo}
+                      </p>
+                    )}
+                  </div>
+                </Popup>
+              </Marker>
+            ))}
+
+            {/* 관광지 마커 (빨간색) */}
+            {attractions.map((attraction) => (
+              attraction.coordinates && (
+                <Marker
+                  key={attraction.id}
+                  position={[attraction.coordinates.lat, attraction.coordinates.lng]}
+                  icon={attractionIcon}
+                >
+                  <Popup>
+                    <div className="p-2 max-w-xs">
+                      <h3 className="font-bold text-gray-800 mb-2 text-base">
+                        {attraction.nameKo}
+                      </h3>
+                      <p className="text-gray-600 text-sm mb-2">
+                        {attraction.description}
+                      </p>
+                      <p className="text-gray-500 text-xs mb-1">
+                        📍 {attraction.location}
+                      </p>
+                      {attraction.admissionFee && (
+                        <p className="text-gray-500 text-xs">
+                          💰 입장료: {attraction.admissionFee.toLocaleString()}엔
+                        </p>
+                      )}
+                    </div>
+                  </Popup>
+                </Marker>
+              )
+            ))}
+          </MapContainer>
+        </div>
+
+        {/* 지도 정보 */}
+        <div className="mt-4 space-y-2">
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-2">
+            <div className="p-3 bg-purple-50 border border-purple-200 rounded text-sm text-purple-800">
+              <strong>🟣 보라색 마커:</strong> 기본 정보 (숙소, 공항, 이동 포인트)
+            </div>
+            <div className="p-3 bg-red-50 border border-red-200 rounded text-sm text-red-800">
+              <strong>🔴 빨간색 마커:</strong> 관광지
+            </div>
+          </div>
+          
+          <div className="p-3 bg-green-50 border border-green-200 rounded text-sm text-green-800">
+            {isCustomTiles ? (
+              <>
+                🎯 <strong>구마모토 전용 지도 서버</strong> 사용 중!
+                <br />
+                <span className="text-xs mt-1 block">
+                  • 빠른 로딩 속도와 오프라인 지원<br />
+                  • Google Maps API 키 불필요<br />
+                  • 구마모토 지역 최적화된 지도 데이터
+                </span>
+              </>
+            ) : (
+              <>
+                🌍 <strong>OpenStreetMap</strong> 사용 중
+                <br />
+                <span className="text-xs mt-1 block">
+                  • 무료 오픈소스 지도 서비스<br />
+                  • API 키 불필요<br />
+                  • Docker 지도 서버 실행 시 더 빠른 성능 제공
+                </span>
+              </>
+            )}
+          </div>
+        </div>
+      </div>
+    )
+  } catch (error) {
+    console.error('지도 렌더링 에러:', error)
+    return (
+      <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-red-50">
+        <div className="text-center">
+          <p className="text-red-500 mb-2">⚠️ 지도를 렌더링할 수 없습니다.</p>
+          <button
+            onClick={() => window.location.reload()}
+            className="px-4 py-2 bg-red-500 text-white rounded hover:bg-red-600"
+          >
+            새로고침
+          </button>
+        </div>
+      </div>
+    )
+  }
+}
+
+export default LeafletMapComponent
diff --git a/src/components/Map.tsx b/src/components/Map.tsx
index 36501c7..abc14d9 100644
--- a/src/components/Map.tsx
+++ b/src/components/Map.tsx
@@ -18,7 +18,7 @@ const attractionIcon = new Icon({
   shadowSize: [41, 41]
 })
 
-const Map = ({ attractions }: MapProps) => {
+const KumamotoMap = ({ attractions }: MapProps) => {
   const [isMounted, setIsMounted] = useState(false)
   
   // 클라이언트 사이드에서만 렌더링 (SSR 에러 방지)
@@ -129,4 +129,4 @@ const Map = ({ attractions }: MapProps) => {
   )
 }
 
-export default Map
+export default KumamotoMap
diff --git a/src/components/MobileTabBar.tsx b/src/components/MobileTabBar.tsx
new file mode 100644
index 0000000..8e5885d
--- /dev/null
+++ b/src/components/MobileTabBar.tsx
@@ -0,0 +1,47 @@
+interface Tab {
+  id: string
+  label: string
+  icon: string
+  badge?: number
+}
+
+interface MobileTabBarProps {
+  tabs: Tab[]
+  activeTab: string
+  onTabChange: (tabId: string) => void
+}
+
+const MobileTabBar = ({ tabs, activeTab, onTabChange }: MobileTabBarProps) => {
+  return (
+    <div className="fixed bottom-0 left-0 right-0 bg-white border-t border-gray-200 z-50">
+      <div className="grid grid-cols-4 h-16">
+        {tabs.map((tab) => (
+          <button
+            key={tab.id}
+            onClick={() => onTabChange(tab.id)}
+            className={`flex flex-col items-center justify-center gap-1 transition-colors relative ${
+              activeTab === tab.id
+                ? 'text-kumamoto-primary bg-kumamoto-light/20'
+                : 'text-gray-600'
+            }`}
+          >
+            <div className="relative">
+              <span className="text-xl">{tab.icon}</span>
+              {tab.badge !== undefined && tab.badge > 0 && (
+                <span className="absolute -top-1 -right-1 inline-flex items-center justify-center w-4 h-4 text-xs font-bold text-white bg-red-500 rounded-full">
+                  {tab.badge > 9 ? '9+' : tab.badge}
+                </span>
+              )}
+            </div>
+            <span className="text-xs font-medium">{tab.label}</span>
+            {activeTab === tab.id && (
+              <div className="absolute top-0 left-1/2 transform -translate-x-1/2 w-8 h-1 bg-kumamoto-primary rounded-full"></div>
+            )}
+          </button>
+        ))}
+      </div>
+    </div>
+  )
+}
+
+export default MobileTabBar
diff --git a/src/components/PlacesSearch.tsx b/src/components/PlacesSearch.tsx
new file mode 100644
index 0000000..1c96215
--- /dev/null
+++ b/src/components/PlacesSearch.tsx
@@ -0,0 +1,272 @@
+import { useState, useEffect, useRef } from 'react'
+import { googlePlacesService, PlaceResult, PlaceSearchOptions, KumamotoSearchPresets } from '../services/googlePlaces'
+
+interface PlacesSearchProps {
+  onPlaceSelect: (place: PlaceResult) => void
+  onAddToItinerary?: (place: PlaceResult) => void
+  currentLocation?: { lat: number; lng: number }
+  className?: string
+}
+
+const PlacesSearch = ({ onPlaceSelect, onAddToItinerary, currentLocation, className = '' }: PlacesSearchProps) => {
+  const [searchQuery, setSearchQuery] = useState('')
+  const [searchResults, setSearchResults] = useState<PlaceResult[]>([])
+  const [isLoading, setIsLoading] = useState(false)
+  const [selectedPreset, setSelectedPreset] = useState<string>('')
+  const [showResults, setShowResults] = useState(false)
+  const [autocompleteResults, setAutocompleteResults] = useState<google.maps.places.AutocompletePrediction[]>([])
+  const [showAutocomplete, setShowAutocomplete] = useState(false)
+  
+  const searchInputRef = useRef<HTMLInputElement>(null)
+  const resultsRef = useRef<HTMLDivElement>(null)
+
+  // 자동완성 검색
+  useEffect(() => {
+    if (searchQuery.length > 2) {
+      const timer = setTimeout(async () => {
+        try {
+          const predictions = await googlePlacesService.getAutocompletePredictions(
+            searchQuery, 
+            currentLocation || { lat: 32.7898, lng: 130.7417 } // 구마모토 중심
+          )
+          setAutocompleteResults(predictions)
+          setShowAutocomplete(true)
+        } catch (error) {
+          console.error('Autocomplete failed:', error)
+          setAutocompleteResults([])
+        }
+      }, 300)
+
+      return () => clearTimeout(timer)
+    } else {
+      setAutocompleteResults([])
+      setShowAutocomplete(false)
+    }
+  }, [searchQuery, currentLocation])
+
+  // 검색 실행
+  const handleSearch = async (options?: PlaceSearchOptions) => {
+    if (!searchQuery.trim() && !options) return
+
+    setIsLoading(true)
+    setShowAutocomplete(false)
+
+    try {
+      const searchOptions: PlaceSearchOptions = options || {
+        query: searchQuery,
+        location: currentLocation || { lat: 32.7898, lng: 130.7417 },
+        radius: 10000
+      }
+
+      const results = await googlePlacesService.textSearch(searchOptions)
+      setSearchResults(results)
+      setShowResults(true)
+    } catch (error) {
+      console.error('Search failed:', error)
+      setSearchResults([])
+      // Google Maps API가 로드되지 않은 경우 사용자에게 알림
+      if (error instanceof Error && error.message.includes('not initialized')) {
+        alert('Google Maps API 키를 먼저 설정해주세요.')
+      }
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  // 프리셋 검색
+  const handlePresetSearch = async (presetKey: string) => {
+    const preset = KumamotoSearchPresets[presetKey as keyof typeof KumamotoSearchPresets]
+    if (preset) {
+      setSelectedPreset(presetKey)
+      setSearchQuery(preset.query)
+      await handleSearch({
+        ...preset,
+        location: currentLocation || { lat: 32.7898, lng: 130.7417 },
+        radius: 15000
+      })
+    }
+  }
+
+  // 자동완성 항목 선택
+  const handleAutocompleteSelect = async (prediction: google.maps.places.AutocompletePrediction) => {
+    setSearchQuery(prediction.description)
+    setShowAutocomplete(false)
+    
+    // Place ID로 상세 정보 가져오기
+    try {
+      const placeDetails = await googlePlacesService.getPlaceDetails(prediction.place_id)
+      if (placeDetails) {
+        setSearchResults([placeDetails])
+        setShowResults(true)
+      }
+    } catch (error) {
+      console.error('Failed to get place details:', error)
+      // 일반 텍스트 검색으로 폴백
+      await handleSearch()
+    }
+  }
+
+  // 장소 선택
+  const handlePlaceClick = (place: PlaceResult) => {
+    onPlaceSelect(place)
+    setShowResults(false)
+  }
+
+  // 일정에 추가
+  const handleAddToItinerary = (place: PlaceResult, event: React.MouseEvent) => {
+    event.stopPropagation()
+    if (onAddToItinerary) {
+      onAddToItinerary(place)
+    }
+  }
+
+  // 가격 레벨 표시
+  const getPriceLevelDisplay = (level?: number) => {
+    if (!level) return ''
+    return '₩'.repeat(level)
+  }
+
+  // 별점 표시
+  const getRatingDisplay = (rating?: number) => {
+    if (!rating) return ''
+    return '⭐'.repeat(Math.floor(rating)) + ` ${rating.toFixed(1)}`
+  }
+
+  return (
+    <div className={`relative ${className}`}>
+      {/* 검색 바 */}
+      <div className="bg-white rounded-lg shadow-md p-4 mb-4">
+        <div className="flex gap-2 mb-3">
+          <div className="flex-1 relative">
+            <input
+              ref={searchInputRef}
+              type="text"
+              value={searchQuery}
+              onChange={(e) => setSearchQuery(e.target.value)}
+              onKeyPress={(e) => e.key === 'Enter' && handleSearch()}
+              placeholder="구마모토 장소 검색... (예: 구마모토성, 라멘집)"
+              className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+            />
+            
+            {/* 자동완성 결과 */}
+            {showAutocomplete && autocompleteResults.length > 0 && (
+              <div className="absolute top-full left-0 right-0 bg-white border border-gray-200 rounded-lg shadow-lg z-50 max-h-60 overflow-y-auto">
+                {autocompleteResults.map((prediction) => (
+                  <button
+                    key={prediction.place_id}
+                    onClick={() => handleAutocompleteSelect(prediction)}
+                    className="w-full text-left px-4 py-2 hover:bg-gray-50 border-b border-gray-100 last:border-b-0"
+                  >
+                    <div className="font-medium text-gray-800">{prediction.structured_formatting.main_text}</div>
+                    <div className="text-sm text-gray-500">{prediction.structured_formatting.secondary_text}</div>
+                  </button>
+                ))}
+              </div>
+            )}
+          </div>
+          
+          <button
+            onClick={() => handleSearch()}
+            disabled={isLoading}
+            className="px-6 py-2 bg-kumamoto-primary text-white rounded-lg hover:bg-kumamoto-primary/90 disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            {isLoading ? '검색중...' : '검색'}
+          </button>
+        </div>
+
+        {/* 프리셋 버튼들 */}
+        <div className="flex flex-wrap gap-2">
+          {Object.entries(KumamotoSearchPresets).map(([key, preset]) => (
+            <button
+              key={key}
+              onClick={() => handlePresetSearch(key)}
+              className={`px-3 py-1 text-sm rounded-full border transition-colors ${
+                selectedPreset === key
+                  ? 'bg-kumamoto-primary text-white border-kumamoto-primary'
+                  : 'bg-white text-gray-700 border-gray-300 hover:bg-gray-50'
+              }`}
+            >
+              {preset.query.replace('구마모토 ', '')}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 검색 결과 */}
+      {showResults && (
+        <div ref={resultsRef} className="bg-white rounded-lg shadow-md max-h-96 overflow-y-auto">
+          <div className="p-4 border-b border-gray-200">
+            <h3 className="font-semibold text-gray-800">
+              검색 결과 ({searchResults.length}개)
+            </h3>
+          </div>
+          
+          {searchResults.length === 0 ? (
+            <div className="p-8 text-center text-gray-500">
+              <div className="text-4xl mb-2">🔍</div>
+              <div>검색 결과가 없습니다.</div>
+              <div className="text-sm">다른 키워드로 검색해보세요.</div>
+            </div>
+          ) : (
+            <div className="divide-y divide-gray-100">
+              {searchResults.map((place) => (
+                <div
+                  key={place.place_id}
+                  onClick={() => handlePlaceClick(place)}
+                  className="p-4 hover:bg-gray-50 cursor-pointer transition-colors"
+                >
+                  <div className="flex justify-between items-start">
+                    <div className="flex-1">
+                      <h4 className="font-medium text-gray-800 mb-1">{place.name}</h4>
+                      <p className="text-sm text-gray-600 mb-2">{place.formatted_address}</p>
+                      
+                      <div className="flex items-center gap-4 text-sm">
+                        {place.rating && (
+                          <span className="text-yellow-600">
+                            {getRatingDisplay(place.rating)}
+                          </span>
+                        )}
+                        {place.price_level && (
+                          <span className="text-green-600">
+                            {getPriceLevelDisplay(place.price_level)}
+                          </span>
+                        )}
+                        {place.opening_hours?.open_now !== undefined && (
+                          <span className={place.opening_hours.open_now ? 'text-green-600' : 'text-red-600'}>
+                            {place.opening_hours.open_now ? '영업중' : '영업종료'}
+                          </span>
+                        )}
+                      </div>
+                      
+                      <div className="flex flex-wrap gap-1 mt-2">
+                        {place.types.slice(0, 3).map((type) => (
+                          <span
+                            key={type}
+                            className="px-2 py-1 bg-gray-100 text-gray-600 text-xs rounded"
+                          >
+                            {type.replace(/_/g, ' ')}
+                          </span>
+                        ))}
+                      </div>
+                    </div>
+                    
+                    {onAddToItinerary && (
+                      <button
+                        onClick={(e) => handleAddToItinerary(place, e)}
+                        className="ml-4 px-3 py-1 bg-kumamoto-primary text-white text-sm rounded hover:bg-kumamoto-primary/90"
+                      >
+                        일정 추가
+                      </button>
+                    )}
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default PlacesSearch
diff --git a/src/components/RelatedPlacesManager.tsx b/src/components/RelatedPlacesManager.tsx
new file mode 100644
index 0000000..4ea06d7
--- /dev/null
+++ b/src/components/RelatedPlacesManager.tsx
@@ -0,0 +1,472 @@
+import { useState } from 'react'
+import { Activity, RelatedPlace } from '../types'
+import CoordinateInput from './forms/CoordinateInput'
+import ImageUploadField from './forms/ImageUploadField'
+import LinkManagement from './forms/LinkManagement'
+
+interface RelatedPlacesManagerProps {
+  activity: Activity
+  onUpdate: (activityId: string, relatedPlaces: RelatedPlace[]) => void
+  onClose: () => void
+}
+
+const RelatedPlacesManager = ({ activity, onUpdate, onClose }: RelatedPlacesManagerProps) => {
+  const [mode, setMode] = useState<'view' | 'add' | 'edit'>('view')
+  const [editingPlace, setEditingPlace] = useState<RelatedPlace | null>(null)
+  const [newPlace, setNewPlace] = useState<Partial<RelatedPlace>>({
+    name: '',
+    description: '',
+    address: '',
+    memo: '',
+  })
+  const [coords, setCoords] = useState<{ lat: number; lng: number } | null>(null)
+  const [uploadImages, setUploadImages] = useState<string[]>([])
+  const [uploadLinks, setUploadLinks] = useState<{ url: string; label?: string }[]>([])
+
+  const handleEditPlace = (place: RelatedPlace) => {
+    setEditingPlace(place)
+    setNewPlace({
+      name: place.name,
+      description: place.description,
+      address: place.address,
+      memo: place.memo,
+      category: place.category,
+    })
+    setCoords(place.coordinates || null)
+    setUploadImages(place.images || [])
+    setUploadLinks(place.links || [])
+    setMode('edit')
+  }
+
+  const handleUpdatePlace = () => {
+    if (!editingPlace) return
+    if (!newPlace.name) {
+      alert('장소 이름을 입력해주세요!')
+      return
+    }
+
+    const validCoords = coords && coords.lat !== 0 && coords.lng !== 0 ? coords : undefined
+
+    const updatedPlace: RelatedPlace = {
+      ...editingPlace,
+      name: newPlace.name,
+      description: newPlace.description,
+      address: newPlace.address,
+      coordinates: validCoords,
+      memo: newPlace.memo,
+      category: newPlace.category,
+      images: uploadImages.length > 0 ? uploadImages : undefined,
+      links: uploadLinks.length > 0 ? uploadLinks : undefined,
+    }
+
+    const updatedPlaces = (activity.relatedPlaces || []).map(p =>
+      p.id === editingPlace.id ? updatedPlace : p
+    )
+    onUpdate(activity.id, updatedPlaces)
+
+    resetForm()
+  }
+
+  const handleAddPlace = () => {
+    if (!newPlace.name) {
+      alert('장소 이름을 입력해주세요!')
+      return
+    }
+
+    const validCoords = coords && coords.lat !== 0 && coords.lng !== 0 ? coords : undefined
+
+    const relatedPlace: RelatedPlace = {
+      id: Date.now().toString(),
+      name: newPlace.name,
+      description: newPlace.description,
+      address: newPlace.address,
+      coordinates: validCoords,
+      memo: newPlace.memo,
+      willVisit: false,
+      category: newPlace.category || 'other',
+      images: uploadImages.length > 0 ? uploadImages : undefined,
+      links: uploadLinks.length > 0 ? uploadLinks : undefined,
+    }
+
+    const updatedPlaces = [...(activity.relatedPlaces || []), relatedPlace]
+    onUpdate(activity.id, updatedPlaces)
+
+    resetForm()
+  }
+
+  const resetForm = () => {
+    setEditingPlace(null)
+    setNewPlace({
+      name: '',
+      description: '',
+      address: '',
+      memo: '',
+    })
+    setCoords(null)
+    setUploadImages([])
+    setUploadLinks([])
+    setMode('view')
+  }
+
+  const handleCancelEdit = () => {
+    resetForm()
+  }
+
+  const toggleWillVisit = (placeId: string) => {
+    const updatedPlaces = (activity.relatedPlaces || []).map((place) =>
+      place.id === placeId
+        ? { ...place, willVisit: !place.willVisit }
+        : place
+    )
+    onUpdate(activity.id, updatedPlaces)
+  }
+
+  const handleDeletePlace = (placeId: string) => {
+    if (!confirm('이 관련 장소를 삭제하시겠습니까?')) return
+
+    const updatedPlaces = (activity.relatedPlaces || []).filter((p) => p.id !== placeId)
+    onUpdate(activity.id, updatedPlaces)
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black/50 flex items-center justify-center z-[2000] p-4">
+      <div className="bg-white rounded-lg shadow-xl max-w-4xl w-full max-h-[90vh] overflow-hidden flex flex-col">
+        {/* 헤더 */}
+        <div className="bg-kumamoto-primary text-white px-6 py-4 flex items-center justify-between">
+          <div>
+            <h2 className="text-xl font-bold">📍 주변 관광지 관리</h2>
+            <p className="text-sm opacity-90 mt-1">{activity.title}</p>
+          </div>
+          <button
+            onClick={onClose}
+            className="text-2xl hover:bg-white/20 w-8 h-8 rounded flex items-center justify-center"
+          >
+            ×
+          </button>
+        </div>
+
+        {/* 탭 전환 */}
+        <div className="flex border-b">
+          <button
+            onClick={() => {
+              if (mode === 'edit' || mode === 'add') {
+                handleCancelEdit()
+              } else {
+                setMode('view')
+              }
+            }}
+            className={`flex-1 px-4 py-3 font-medium transition-colors ${
+              mode === 'view'
+                ? 'bg-white text-kumamoto-primary border-b-2 border-kumamoto-primary'
+                : 'bg-gray-50 text-gray-600 hover:bg-gray-100'
+            }`}
+          >
+            📋 목록 보기 ({activity.relatedPlaces?.length || 0})
+          </button>
+          <button
+            onClick={() => {
+              if (mode === 'edit') {
+                handleCancelEdit()
+              }
+              setMode('add')
+            }}
+            className={`flex-1 px-4 py-3 font-medium transition-colors ${
+              mode === 'add'
+                ? 'bg-white text-kumamoto-primary border-b-2 border-kumamoto-primary'
+                : 'bg-gray-50 text-gray-600 hover:bg-gray-100'
+            }`}
+          >
+            ➕ 새로 추가
+          </button>
+        </div>
+
+        {/* 컨텐츠 영역 */}
+        <div className="flex-1 overflow-y-auto p-6">
+          {mode === 'view' ? (
+            // 목록 보기 모드
+            <div>
+              {activity.relatedPlaces && activity.relatedPlaces.length > 0 ? (
+                <div className="space-y-3">
+                  {activity.relatedPlaces.map((place, index) => (
+                    <div
+                      key={place.id}
+                      className={`border rounded-lg p-4 hover:shadow-md transition-all ${
+                        place.willVisit
+                          ? 'bg-green-50 border-green-300'
+                          : 'bg-gray-50 border-gray-200'
+                      }`}
+                    >
+                      <div className="flex items-start gap-3">
+                        {/* 체크박스 */}
+                        <div className="pt-1">
+                          <input
+                            type="checkbox"
+                            checked={place.willVisit || false}
+                            onChange={() => toggleWillVisit(place.id)}
+                            className="w-5 h-5 text-green-600 rounded focus:ring-2 focus:ring-green-500 cursor-pointer"
+                            title="가볼 곳으로 선택"
+                          />
+                        </div>
+
+                        <div className="flex-1">
+                          <div className="flex items-center gap-2 mb-2">
+                            <span className="inline-flex items-center justify-center w-6 h-6 bg-kumamoto-primary text-white text-xs font-bold rounded-full">
+                              {index + 1}
+                            </span>
+                            <h3 className="text-lg font-bold text-gray-800">{place.name}</h3>
+                            {place.category && (
+                              <span className={`px-2 py-0.5 text-white text-xs rounded-full ${
+                                place.category === 'restaurant' ? 'bg-orange-500' :
+                                place.category === 'attraction' ? 'bg-blue-500' :
+                                place.category === 'shopping' ? 'bg-pink-500' :
+                                place.category === 'accommodation' ? 'bg-purple-500' :
+                                'bg-gray-500'
+                              }`}>
+                                {place.category === 'restaurant' ? '🍴 식당' :
+                                 place.category === 'attraction' ? '🏞️ 관광지' :
+                                 place.category === 'shopping' ? '🛍️ 쇼핑' :
+                                 place.category === 'accommodation' ? '🏨 숙소' :
+                                 '📍 기타'}
+                              </span>
+                            )}
+                            {place.willVisit && (
+                              <span className="px-2 py-0.5 bg-green-500 text-white text-xs rounded-full">
+                                ✓ 가볼 곳
+                              </span>
+                            )}
+                          </div>
+
+                          {place.address && (
+                            <div className="text-sm text-gray-600 mb-2">
+                              📍 {place.address}
+                            </div>
+                          )}
+
+                          {place.coordinates && (
+                            <div className="text-xs text-purple-600 mb-2">
+                              🗺️ 좌표: {place.coordinates.lat.toFixed(4)}, {place.coordinates.lng.toFixed(4)}
+                            </div>
+                          )}
+
+                          {place.description && (
+                            <div className="text-sm text-gray-700 bg-white rounded p-2 mb-2">
+                              {place.description}
+                            </div>
+                          )}
+
+                          {place.memo && (
+                            <div className="text-sm text-kumamoto-primary bg-blue-50 rounded p-2 italic mb-2">
+                              💡 {place.memo}
+                            </div>
+                          )}
+
+                          {/* 이미지 갤러리 */}
+                          {place.images && place.images.length > 0 && (
+                            <div className="grid grid-cols-3 gap-2 mt-2">
+                              {place.images.map((img, imgIdx) => (
+                                <img
+                                  key={imgIdx}
+                                  src={`http://localhost:3000${img}`}
+                                  alt={`${place.name} ${imgIdx + 1}`}
+                                  className="w-full h-20 object-cover rounded border border-gray-200"
+                                />
+                              ))}
+                            </div>
+                          )}
+
+                          {/* 링크 목록 */}
+                          {place.links && place.links.length > 0 && (
+                            <div className="mt-2 space-y-1">
+                              {place.links.map((link, linkIdx) => (
+                                <a
+                                  key={linkIdx}
+                                  href={link.url}
+                                  target="_blank"
+                                  rel="noopener noreferrer"
+                                  className="block text-xs text-blue-600 hover:underline bg-blue-50 px-2 py-1 rounded truncate"
+                                >
+                                  🔗 {link.label || link.url}
+                                </a>
+                              ))}
+                            </div>
+                          )}
+                        </div>
+
+                        <div className="ml-4 flex flex-col gap-2">
+                          <button
+                            onClick={() => handleEditPlace(place)}
+                            className="px-3 py-1 bg-blue-100 text-blue-700 hover:bg-blue-200 rounded text-sm transition-colors whitespace-nowrap"
+                          >
+                            편집
+                          </button>
+                          <button
+                            onClick={() => handleDeletePlace(place.id)}
+                            className="px-3 py-1 bg-red-100 text-red-700 hover:bg-red-200 rounded text-sm transition-colors whitespace-nowrap"
+                          >
+                            삭제
+                          </button>
+                        </div>
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              ) : (
+                <div className="text-center py-12 text-gray-400">
+                  <div className="text-5xl mb-4">📭</div>
+                  <p className="text-lg">등록된 관련 장소가 없습니다.</p>
+                  <button
+                    onClick={() => setMode('add')}
+                    className="mt-4 px-4 py-2 bg-kumamoto-primary text-white rounded hover:bg-kumamoto-secondary transition-colors"
+                  >
+                    첫 장소 추가하기
+                  </button>
+                </div>
+              )}
+            </div>
+          ) : (
+            // 추가/편집 모드 (통합된 폼)
+            <div className="max-w-2xl mx-auto">
+              <div className={`border rounded-lg p-4 mb-6 ${
+                mode === 'edit' ? 'bg-amber-50 border-amber-200' : 'bg-blue-50 border-blue-200'
+              }`}>
+                <div className="flex items-start gap-3">
+                  <div className="text-2xl">{mode === 'edit' ? '✏️' : '💡'}</div>
+                  <div className="flex-1 text-sm text-gray-700">
+                    <p className="font-medium mb-1">
+                      {mode === 'edit' ? '주변 관광지 편집 중' : '주변 관광지 등록 팁'}
+                    </p>
+                    {mode === 'edit' ? (
+                      <p className="text-xs">
+                        "{editingPlace?.name}" 정보를 수정하고 있습니다.
+                      </p>
+                    ) : (
+                      <ul className="list-disc list-inside space-y-1 text-xs">
+                        <li>Google Maps에서 장소를 검색하고 우클릭하여 좌표를 복사할 수 있습니다</li>
+                        <li>메모 필드에는 방문 시간, 소요 시간, 추천 이유 등을 적어두세요</li>
+                        <li>나중에 Trip 페이지에서 지도에 표시됩니다</li>
+                      </ul>
+                    )}
+                  </div>
+                </div>
+              </div>
+
+              <div className="space-y-4">
+                {/* 장소 이름 */}
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">
+                    장소 이름 <span className="text-red-500">*</span>
+                  </label>
+                  <input
+                    type="text"
+                    placeholder="예: 아소 화산 박물관"
+                    value={newPlace.name}
+                    onChange={(e) => setNewPlace({ ...newPlace, name: e.target.value })}
+                    className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+                  />
+                </div>
+
+                {/* 주소 */}
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">
+                    주소
+                  </label>
+                  <input
+                    type="text"
+                    placeholder="예: 熊本県阿蘇市赤水"
+                    value={newPlace.address}
+                    onChange={(e) => setNewPlace({ ...newPlace, address: e.target.value })}
+                    className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+                  />
+                </div>
+
+                {/* 카테고리 */}
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">
+                    카테고리
+                  </label>
+                  <select
+                    value={newPlace.category || 'other'}
+                    onChange={(e) => setNewPlace({ ...newPlace, category: e.target.value as RelatedPlace['category'] })}
+                    className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+                  >
+                    <option value="restaurant">🍴 식당/맛집</option>
+                    <option value="attraction">🏞️ 관광지</option>
+                    <option value="shopping">🛍️ 쇼핑</option>
+                    <option value="accommodation">🏨 숙소</option>
+                    <option value="other">📍 기타</option>
+                  </select>
+                </div>
+
+                {/* 좌표 입력 - CoordinateInput 사용 */}
+                <CoordinateInput
+                  coordinates={coords}
+                  onChange={setCoords}
+                />
+
+                {/* 설명 */}
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">
+                    설명
+                  </label>
+                  <textarea
+                    placeholder="예: 아소산의 화산 활동과 역사를 전시하는 박물관"
+                    value={newPlace.description}
+                    onChange={(e) => setNewPlace({ ...newPlace, description: e.target.value })}
+                    className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+                    rows={3}
+                  />
+                </div>
+
+                {/* 메모 / 팁 */}
+                <div>
+                  <label className="block text-sm font-medium text-gray-700 mb-1">
+                    메모 / 팁
+                  </label>
+                  <textarea
+                    placeholder="예: 쿠사센리 바로 옆에 위치. 소요 시간 약 30분"
+                    value={newPlace.memo}
+                    onChange={(e) => setNewPlace({ ...newPlace, memo: e.target.value })}
+                    className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+                    rows={2}
+                  />
+                </div>
+
+                {/* 이미지 업로드 - ImageUploadField 사용 */}
+                <ImageUploadField
+                  images={uploadImages}
+                  onChange={setUploadImages}
+                />
+
+                {/* 링크 추가 - LinkManagement 사용 */}
+                <LinkManagement
+                  links={uploadLinks}
+                  onChange={setUploadLinks}
+                />
+
+                {/* 버튼 */}
+                <div className="flex gap-3 pt-4">
+                  <button
+                    onClick={mode === 'edit' ? handleUpdatePlace : handleAddPlace}
+                    className={`flex-1 px-6 py-3 text-white rounded-lg hover:bg-opacity-90 font-medium transition-colors ${
+                      mode === 'edit' ? 'bg-kumamoto-blue' : 'bg-kumamoto-green'
+                    }`}
+                  >
+                    {mode === 'edit' ? '✓ 수정 완료' : '✓ 추가하기'}
+                  </button>
+                  <button
+                    onClick={handleCancelEdit}
+                    className="px-6 py-3 bg-gray-200 text-gray-700 rounded-lg hover:bg-gray-300 font-medium transition-colors"
+                  >
+                    취소
+                  </button>
+                </div>
+              </div>
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default RelatedPlacesManager
diff --git a/src/components/RouteOptimizer.tsx b/src/components/RouteOptimizer.tsx
new file mode 100644
index 0000000..c0e869a
--- /dev/null
+++ b/src/components/RouteOptimizer.tsx
@@ -0,0 +1,239 @@
+import { useState } from 'react'
+import { googleDirectionsService, OptimizedItinerary, TravelModeOptions, KumamotoRoutePresets } from '../services/googleDirections'
+
+interface RouteOptimizerProps {
+  activities: any[]
+  onOptimizedRoute?: (optimizedItinerary: OptimizedItinerary) => void
+  onApplyOptimization?: (optimizedActivities: any[]) => void
+  className?: string
+}
+
+const RouteOptimizer = ({ 
+  activities, 
+  onOptimizedRoute, 
+  onApplyOptimization,
+  className = '' 
+}: RouteOptimizerProps) => {
+  const [isOptimizing, setIsOptimizing] = useState(false)
+  const [optimizedResult, setOptimizedResult] = useState<OptimizedItinerary | null>(null)
+  const [selectedTravelMode, setSelectedTravelMode] = useState<string>('DRIVING')
+  const [error, setError] = useState<string | null>(null)
+
+  // 최적화 실행
+  const handleOptimize = async () => {
+    if (activities.length < 2) {
+      setError('최소 2개 이상의 활동이 필요합니다')
+      return
+    }
+
+    setIsOptimizing(true)
+    setError(null)
+
+    try {
+      // Google Maps API 초기화 확인
+      if (typeof google === 'undefined' || !google.maps) {
+        throw new Error('Google Maps API가 로드되지 않았습니다')
+      }
+
+      googleDirectionsService.initialize()
+      
+      const result = await googleDirectionsService.optimizeItinerary(activities, selectedTravelMode)
+      setOptimizedResult(result)
+      
+      if (onOptimizedRoute) {
+        onOptimizedRoute(result)
+      }
+    } catch (err) {
+      console.error('Route optimization failed:', err)
+      setError(err instanceof Error ? err.message : '경로 최적화에 실패했습니다')
+    } finally {
+      setIsOptimizing(false)
+    }
+  }
+
+  // 최적화 결과 적용
+  const handleApplyOptimization = () => {
+    if (optimizedResult && onApplyOptimization) {
+      onApplyOptimization(optimizedResult.optimizedActivities)
+      setOptimizedResult(null)
+    }
+  }
+
+  // 여행 모드별 아이콘
+  const getTravelModeIcon = (mode: string) => {
+    switch (mode) {
+      case 'DRIVING':
+        return '🚗'
+      case 'TRANSIT':
+        return '🚌'
+      case 'WALKING':
+        return '🚶'
+      default:
+        return '🗺️'
+    }
+  }
+
+  // 좌표가 있는 활동 개수
+  const activitiesWithCoords = activities.filter(activity => 
+    activity.coordinates && activity.coordinates.lat && activity.coordinates.lng
+  ).length
+
+  return (
+    <div className={`bg-white rounded-lg shadow-md p-4 ${className}`}>
+      <div className="flex items-center justify-between mb-4">
+        <h3 className="text-lg font-semibold text-gray-800">🗺️ 경로 최적화</h3>
+        <div className="text-sm text-gray-500">
+          {activitiesWithCoords}/{activities.length}개 활동
+        </div>
+      </div>
+
+      {/* 여행 모드 선택 */}
+      <div className="mb-4">
+        <label className="block text-sm font-medium text-gray-700 mb-2">
+          이동 수단 선택
+        </label>
+        <div className="grid grid-cols-3 gap-2">
+          {Object.entries(TravelModeOptions).map(([key, option]) => (
+            <button
+              key={key}
+              onClick={() => setSelectedTravelMode(option.mode)}
+              className={`p-3 text-sm rounded-lg border transition-colors ${
+                selectedTravelMode === option.mode
+                  ? 'bg-kumamoto-primary text-white border-kumamoto-primary'
+                  : 'bg-white text-gray-700 border-gray-300 hover:bg-gray-50'
+              }`}
+            >
+              <div className="text-lg mb-1">{getTravelModeIcon(option.mode)}</div>
+              <div className="font-medium">{option.label.replace(/🚗|🚌|🚶/, '').trim()}</div>
+              <div className="text-xs opacity-75">{option.description}</div>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 최적화 버튼 */}
+      <div className="mb-4">
+        <button
+          onClick={handleOptimize}
+          disabled={isOptimizing || activitiesWithCoords < 2}
+          className="w-full py-3 px-4 bg-kumamoto-primary text-white rounded-lg hover:bg-kumamoto-primary/90 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+        >
+          {isOptimizing ? (
+            <div className="flex items-center justify-center gap-2">
+              <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+              경로 계산 중...
+            </div>
+          ) : (
+            `${getTravelModeIcon(selectedTravelMode)} 최적 경로 계산`
+          )}
+        </button>
+        
+        {activitiesWithCoords < 2 && (
+          <p className="text-xs text-gray-500 mt-2 text-center">
+            좌표 정보가 있는 활동이 최소 2개 필요합니다
+          </p>
+        )}
+      </div>
+
+      {/* 에러 메시지 */}
+      {error && (
+        <div className="mb-4 p-3 bg-red-50 border border-red-200 rounded-lg">
+          <div className="flex items-center gap-2 text-red-700">
+            <span>⚠️</span>
+            <span className="text-sm">{error}</span>
+          </div>
+        </div>
+      )}
+
+      {/* 최적화 결과 */}
+      {optimizedResult && (
+        <div className="border-t border-gray-200 pt-4">
+          <h4 className="font-medium text-gray-800 mb-3">📊 최적화 결과</h4>
+          
+          {/* 개선 효과 */}
+          <div className="grid grid-cols-2 gap-4 mb-4">
+            <div className="bg-green-50 p-3 rounded-lg border border-green-200">
+              <div className="text-sm text-green-700 font-medium">⏱️ 시간</div>
+              <div className="text-lg font-bold text-green-800">
+                {optimizedResult.timeSaved}
+              </div>
+            </div>
+            <div className="bg-blue-50 p-3 rounded-lg border border-blue-200">
+              <div className="text-sm text-blue-700 font-medium">📏 거리</div>
+              <div className="text-lg font-bold text-blue-800">
+                {optimizedResult.distanceSaved}
+              </div>
+            </div>
+          </div>
+
+          {/* 총 경로 정보 */}
+          <div className="bg-gray-50 p-3 rounded-lg mb-4">
+            <div className="grid grid-cols-2 gap-4 text-sm">
+              <div>
+                <span className="text-gray-600">총 거리:</span>
+                <span className="font-medium ml-2">{optimizedResult.routeResult.totalDistance}</span>
+              </div>
+              <div>
+                <span className="text-gray-600">총 시간:</span>
+                <span className="font-medium ml-2">{optimizedResult.routeResult.totalDuration}</span>
+              </div>
+            </div>
+          </div>
+
+          {/* 최적화된 순서 */}
+          <div className="mb-4">
+            <h5 className="text-sm font-medium text-gray-700 mb-2">🎯 최적화된 순서</h5>
+            <div className="space-y-2 max-h-40 overflow-y-auto">
+              {optimizedResult.optimizedActivities.map((activity, index) => (
+                <div key={activity.id} className="flex items-center gap-3 p-2 bg-gray-50 rounded">
+                  <div className="w-6 h-6 bg-kumamoto-primary text-white rounded-full flex items-center justify-center text-xs font-bold">
+                    {index + 1}
+                  </div>
+                  <div className="flex-1 min-w-0">
+                    <div className="text-sm font-medium text-gray-800 truncate">
+                      {activity.title}
+                    </div>
+                    <div className="text-xs text-gray-500 truncate">
+                      {activity.time} • {activity.location}
+                    </div>
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {/* 적용 버튼 */}
+          <div className="flex gap-2">
+            <button
+              onClick={handleApplyOptimization}
+              className="flex-1 py-2 px-4 bg-green-600 text-white rounded-lg hover:bg-green-700 transition-colors"
+            >
+              ✅ 최적화된 순서 적용
+            </button>
+            <button
+              onClick={() => setOptimizedResult(null)}
+              className="px-4 py-2 bg-gray-300 text-gray-700 rounded-lg hover:bg-gray-400 transition-colors"
+            >
+              취소
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* 도움말 */}
+      <div className="mt-4 p-3 bg-blue-50 border border-blue-200 rounded-lg">
+        <div className="text-sm text-blue-800">
+          <div className="font-medium mb-1">💡 경로 최적화 팁</div>
+          <ul className="text-xs space-y-1 text-blue-700">
+            <li>• 좌표 정보가 있는 활동만 최적화됩니다</li>
+            <li>• 시작점과 끝점은 고정되고 중간 경유지만 최적화됩니다</li>
+            <li>• 실시간 교통 상황이 반영됩니다</li>
+            <li>• {getTravelModeIcon(selectedTravelMode)} 선택한 이동 수단에 맞는 경로를 계산합니다</li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default RouteOptimizer
diff --git a/src/components/SharedTripViewer.tsx b/src/components/SharedTripViewer.tsx
new file mode 100644
index 0000000..e98a8af
--- /dev/null
+++ b/src/components/SharedTripViewer.tsx
@@ -0,0 +1,428 @@
+import { useState, useEffect } from 'react'
+import { useParams, Link } from 'react-router-dom'
+import { CollaborativeTrip, TripComment } from '../types'
+import { tripSharingService } from '../services/tripSharing'
+import { userAuthService } from '../services/userAuth'
+import { format, eachDayOfInterval } from 'date-fns'
+import UnifiedMap from './UnifiedMap'
+
+const SharedTripViewer = () => {
+  const { shareCode } = useParams<{ shareCode: string }>()
+  const [collaborativeTrip, setCollaborativeTrip] = useState<CollaborativeTrip | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [currentDay, setCurrentDay] = useState(0)
+  const [showComments, setShowComments] = useState(false)
+  const [newComment, setNewComment] = useState('')
+  const [isAddingComment, setIsAddingComment] = useState(false)
+
+  const currentUser = userAuthService.getCurrentUser()
+
+  useEffect(() => {
+    if (shareCode) {
+      loadSharedTrip(shareCode)
+    }
+  }, [shareCode])
+
+  const loadSharedTrip = async (code: string) => {
+    try {
+      setIsLoading(true)
+      const result = await tripSharingService.getTripByShareCode(code)
+      
+      if (result.success && result.trip) {
+        setCollaborativeTrip(result.trip)
+        
+        // 현재 날짜에 해당하는 일차 찾기
+        const today = new Date()
+        const days = eachDayOfInterval({
+          start: new Date(result.trip.trip.startDate),
+          end: new Date(result.trip.trip.endDate),
+        })
+        
+        const todayIndex = days.findIndex(day => 
+          format(day, 'yyyy-MM-dd') === format(today, 'yyyy-MM-dd')
+        )
+        
+        if (todayIndex !== -1) {
+          setCurrentDay(todayIndex)
+        }
+      } else {
+        setError(result.message || '공유된 여행 계획을 불러올 수 없습니다')
+      }
+    } catch (err) {
+      setError('공유된 여행 계획을 불러오는 중 오류가 발생했습니다')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleAddComment = async () => {
+    if (!collaborativeTrip || !newComment.trim() || !currentUser) {
+      return
+    }
+
+    setIsAddingComment(true)
+    try {
+      const result = await tripSharingService.addComment(collaborativeTrip.trip.id, newComment.trim())
+      
+      if (result.success && result.comment) {
+        setCollaborativeTrip({
+          ...collaborativeTrip,
+          comments: [...collaborativeTrip.comments, result.comment]
+        })
+        setNewComment('')
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('댓글 추가 중 오류가 발생했습니다')
+    } finally {
+      setIsAddingComment(false)
+    }
+  }
+
+  const formatDate = (date: Date | string) => {
+    return format(new Date(date), 'M월 d일 (E)', { locale: undefined })
+  }
+
+  const formatDateTime = (dateString: string) => {
+    return new Date(dateString).toLocaleDateString('ko-KR', {
+      month: 'short',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  }
+
+  if (isLoading) {
+    return (
+      <div className="min-h-screen bg-gray-100 flex items-center justify-center">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
+          <div className="text-lg text-gray-600">공유된 여행 계획을 불러오는 중...</div>
+        </div>
+      </div>
+    )
+  }
+
+  if (error || !collaborativeTrip) {
+    return (
+      <div className="min-h-screen bg-gray-100 flex items-center justify-center">
+        <div className="text-center p-6">
+          <div className="text-4xl mb-4">⚠️</div>
+          <div className="text-lg font-medium text-gray-800 mb-2">
+            {error || '공유된 여행 계획을 찾을 수 없습니다'}
+          </div>
+          <div className="text-gray-600 mb-4">
+            링크가 만료되었거나 유효하지 않을 수 있습니다
+          </div>
+          <Link
+            to="/"
+            className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+          >
+            메인으로 돌아가기
+          </Link>
+        </div>
+      </div>
+    )
+  }
+
+  const { trip, share_link, comments } = collaborativeTrip
+  const days = eachDayOfInterval({
+    start: new Date(trip.startDate),
+    end: new Date(trip.endDate),
+  })
+
+  const currentDaySchedule = trip.schedule.find(
+    (daySchedule) =>
+      format(daySchedule.date, 'yyyy-MM-dd') === format(days[currentDay], 'yyyy-MM-dd')
+  )
+
+  const canComment = share_link.permissions.can_comment && currentUser
+  const canEdit = share_link.permissions.can_edit && currentUser
+
+  return (
+    <div className="min-h-screen bg-gray-100">
+      {/* 헤더 */}
+      <div className="bg-white shadow-sm border-b border-gray-200">
+        <div className="max-w-7xl mx-auto px-4 py-4">
+          <div className="flex items-center justify-between">
+            <div>
+              <div className="flex items-center gap-3 mb-2">
+                <h1 className="text-2xl font-bold text-gray-800">{trip.title}</h1>
+                <span className="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-blue-100 text-blue-800">
+                  공유된 여행 계획
+                </span>
+              </div>
+              <div className="flex items-center gap-4 text-sm text-gray-600">
+                <span>📍 {trip.destination.city}, {trip.destination.country}</span>
+                <span>📅 {formatDate(trip.startDate)} - {formatDate(trip.endDate)}</span>
+                <span>👥 {share_link.access_count}명이 조회</span>
+              </div>
+            </div>
+            
+            <div className="flex items-center gap-3">
+              {canComment && (
+                <button
+                  onClick={() => setShowComments(!showComments)}
+                  className="px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700 flex items-center gap-2"
+                >
+                  💬 댓글 ({comments.length})
+                </button>
+              )}
+              {canEdit && (
+                <Link
+                  to={`/plan/${trip.id}`}
+                  className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 flex items-center gap-2"
+                >
+                  ✏️ 편집하기
+                </Link>
+              )}
+            </div>
+          </div>
+
+          {/* 권한 정보 */}
+          <div className="mt-3 p-3 bg-gray-50 rounded-lg">
+            <div className="flex items-center gap-4 text-sm">
+              <span className="font-medium text-gray-700">공유 권한:</span>
+              <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${
+                share_link.permissions.can_edit ? 'bg-red-100 text-red-800' :
+                share_link.permissions.can_comment ? 'bg-yellow-100 text-yellow-800' :
+                'bg-green-100 text-green-800'
+              }`}>
+                {share_link.permissions.can_edit ? '편집 가능' :
+                 share_link.permissions.can_comment ? '댓글 가능' : '보기 전용'}
+              </span>
+              {share_link.expires_at && (
+                <span className="text-gray-500">
+                  만료: {formatDateTime(share_link.expires_at)}
+                </span>
+              )}
+            </div>
+          </div>
+
+          {/* 날짜 선택 탭 */}
+          <div className="flex gap-2 mt-4 overflow-x-auto pb-2">
+            {days.map((day, index) => (
+              <button
+                key={day.toISOString()}
+                onClick={() => setCurrentDay(index)}
+                className={`px-4 py-2 rounded-lg whitespace-nowrap text-sm transition-colors ${
+                  currentDay === index
+                    ? 'bg-blue-600 text-white'
+                    : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+                }`}
+              >
+                <div className="font-medium">{formatDate(day)}</div>
+                <div className="text-xs opacity-75">
+                  {index + 1}일차
+                </div>
+              </button>
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {/* 메인 콘텐츠 */}
+      <div className="max-w-7xl mx-auto px-4 py-6">
+        <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+          {/* 지도 영역 */}
+          <div className="lg:col-span-2">
+            <div className="bg-white rounded-lg shadow-md overflow-hidden">
+              <div className="h-96 lg:h-[600px]">
+                <UnifiedMap
+                  attractions={[]}
+                  currentDaySchedule={currentDaySchedule}
+                  showControls={false}
+                  className="h-full rounded-none shadow-none"
+                />
+              </div>
+            </div>
+          </div>
+
+          {/* 일정 및 댓글 영역 */}
+          <div className="space-y-6">
+            {/* 오늘의 일정 */}
+            <div className="bg-white rounded-lg shadow-md">
+              <div className="p-4 border-b border-gray-200">
+                <h2 className="text-lg font-semibold text-gray-800">
+                  {formatDate(days[currentDay])} 일정
+                </h2>
+              </div>
+              
+              <div className="p-4">
+                {currentDaySchedule && currentDaySchedule.activities.length > 0 ? (
+                  <div className="space-y-3">
+                    {currentDaySchedule.activities.map((activity) => (
+                      <div
+                        key={activity.id}
+                        className="p-3 bg-gray-50 rounded-lg border border-gray-200"
+                      >
+                        <div className="flex items-start gap-3">
+                          <div className="text-sm font-medium text-blue-600 mt-0.5">
+                            {activity.time}
+                          </div>
+                          <div className="flex-1">
+                            <h3 className="font-medium text-gray-800 mb-1">
+                              {activity.title}
+                            </h3>
+                            {activity.location && (
+                              <div className="text-sm text-gray-600 mb-1">
+                                📍 {activity.location}
+                              </div>
+                            )}
+                            {activity.description && (
+                              <div className="text-sm text-gray-500">
+                                {activity.description}
+                              </div>
+                            )}
+                            <div className="mt-2">
+                              <span className={`inline-block px-2 py-1 text-xs rounded-full ${
+                                activity.type === 'attraction' ? 'bg-green-100 text-green-800' :
+                                activity.type === 'food' ? 'bg-orange-100 text-orange-800' :
+                                activity.type === 'accommodation' ? 'bg-purple-100 text-purple-800' :
+                                activity.type === 'transport' ? 'bg-blue-100 text-blue-800' :
+                                'bg-gray-100 text-gray-800'
+                              }`}>
+                                {activity.type === 'attraction' ? '관광' :
+                                 activity.type === 'food' ? '식사' :
+                                 activity.type === 'accommodation' ? '숙박' :
+                                 activity.type === 'transport' ? '이동' : '기타'}
+                              </span>
+                            </div>
+                          </div>
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                ) : (
+                  <div className="text-center py-8">
+                    <div className="text-4xl mb-3">📅</div>
+                    <div className="text-gray-600">
+                      이 날짜에 계획된 일정이 없습니다
+                    </div>
+                  </div>
+                )}
+              </div>
+            </div>
+
+            {/* 여행 정보 */}
+            <div className="bg-white rounded-lg shadow-md">
+              <div className="p-4 border-b border-gray-200">
+                <h3 className="font-semibold text-gray-800">여행 정보</h3>
+              </div>
+              <div className="p-4 space-y-3 text-sm">
+                <div className="flex justify-between">
+                  <span className="text-gray-600">목적지</span>
+                  <span className="font-medium">
+                    {trip.destination.city}, {trip.destination.country}
+                  </span>
+                </div>
+                <div className="flex justify-between">
+                  <span className="text-gray-600">기간</span>
+                  <span className="font-medium">
+                    {format(new Date(trip.startDate), 'M/d')} - {format(new Date(trip.endDate), 'M/d')}
+                  </span>
+                </div>
+                <div className="flex justify-between">
+                  <span className="text-gray-600">총 일정</span>
+                  <span className="font-medium">
+                    {trip.schedule.reduce((total, day) => total + day.activities.length, 0)}개
+                  </span>
+                </div>
+                {trip.description && (
+                  <div className="pt-2 border-t border-gray-200">
+                    <div className="text-gray-600 text-xs mb-1">설명</div>
+                    <div className="text-gray-800">{trip.description}</div>
+                  </div>
+                )}
+                {trip.tags.length > 0 && (
+                  <div className="pt-2 border-t border-gray-200">
+                    <div className="text-gray-600 text-xs mb-2">태그</div>
+                    <div className="flex flex-wrap gap-1">
+                      {trip.tags.map((tag) => (
+                        <span
+                          key={tag}
+                          className="inline-block px-2 py-1 bg-gray-100 text-gray-600 text-xs rounded"
+                        >
+                          #{tag}
+                        </span>
+                      ))}
+                    </div>
+                  </div>
+                )}
+              </div>
+            </div>
+
+            {/* 댓글 섹션 */}
+            {canComment && (
+              <div className="bg-white rounded-lg shadow-md">
+                <div className="p-4 border-b border-gray-200">
+                  <h3 className="font-semibold text-gray-800">
+                    댓글 ({comments.length})
+                  </h3>
+                </div>
+                
+                <div className="p-4">
+                  {/* 댓글 작성 */}
+                  <div className="mb-4">
+                    <textarea
+                      value={newComment}
+                      onChange={(e) => setNewComment(e.target.value)}
+                      placeholder="이 여행 계획에 대한 의견을 남겨보세요..."
+                      className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent resize-none"
+                      rows={3}
+                    />
+                    <div className="flex justify-between items-center mt-2">
+                      <div className="text-xs text-gray-500">
+                        {currentUser ? `${currentUser.name}으로 댓글 작성` : '로그인이 필요합니다'}
+                      </div>
+                      <button
+                        onClick={handleAddComment}
+                        disabled={!newComment.trim() || isAddingComment}
+                        className="px-4 py-2 bg-blue-600 text-white rounded text-sm hover:bg-blue-700 disabled:opacity-50"
+                      >
+                        {isAddingComment ? '작성 중...' : '댓글 작성'}
+                      </button>
+                    </div>
+                  </div>
+
+                  {/* 댓글 목록 */}
+                  {comments.length > 0 ? (
+                    <div className="space-y-3">
+                      {comments.map((comment) => (
+                        <div key={comment.id} className="border border-gray-200 rounded p-3">
+                          <div className="flex items-center justify-between mb-2">
+                            <div className="font-medium text-gray-800 text-sm">
+                              {comment.user_name}
+                            </div>
+                            <div className="text-xs text-gray-500">
+                              {formatDateTime(comment.created_at)}
+                              {comment.is_edited && ' (수정됨)'}
+                            </div>
+                          </div>
+                          <div className="text-gray-700 text-sm">
+                            {comment.content}
+                          </div>
+                        </div>
+                      ))}
+                    </div>
+                  ) : (
+                    <div className="text-center py-6">
+                      <div className="text-gray-500 text-sm">
+                        아직 댓글이 없습니다. 첫 번째 댓글을 남겨보세요!
+                      </div>
+                    </div>
+                  )}
+                </div>
+              </div>
+            )}
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default SharedTripViewer
diff --git a/src/components/TabNavigation.tsx b/src/components/TabNavigation.tsx
new file mode 100644
index 0000000..f75cd43
--- /dev/null
+++ b/src/components/TabNavigation.tsx
@@ -0,0 +1,55 @@
+import { ReactNode } from 'react'
+
+interface Tab {
+  id: string
+  label: string
+  icon: string
+  content: ReactNode
+  badge?: number
+}
+
+interface TabNavigationProps {
+  tabs: Tab[]
+  activeTab: string
+  onTabChange: (tabId: string) => void
+}
+
+const TabNavigation = ({ tabs, activeTab, onTabChange }: TabNavigationProps) => {
+  return (
+    <div className="bg-white rounded-lg shadow-md overflow-hidden">
+      {/* 탭 헤더 */}
+      <div className="border-b border-gray-200">
+        <div className="flex">
+          {tabs.map((tab) => (
+            <button
+              key={tab.id}
+              onClick={() => onTabChange(tab.id)}
+              className={`flex-1 px-4 py-3 text-sm font-medium transition-colors relative ${
+                activeTab === tab.id
+                  ? 'text-kumamoto-primary border-b-2 border-kumamoto-primary bg-kumamoto-light/20'
+                  : 'text-gray-600 hover:text-gray-800 hover:bg-gray-50'
+              }`}
+            >
+              <div className="flex items-center justify-center gap-2">
+                <span className="text-lg">{tab.icon}</span>
+                <span>{tab.label}</span>
+                {tab.badge !== undefined && tab.badge > 0 && (
+                  <span className="inline-flex items-center justify-center w-5 h-5 text-xs font-bold text-white bg-red-500 rounded-full">
+                    {tab.badge > 99 ? '99+' : tab.badge}
+                  </span>
+                )}
+              </div>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 탭 콘텐츠 */}
+      <div className="p-6">
+        {tabs.find(tab => tab.id === activeTab)?.content}
+      </div>
+    </div>
+  )
+}
+
+export default TabNavigation
diff --git a/src/components/TemplateBrowser.tsx b/src/components/TemplateBrowser.tsx
new file mode 100644
index 0000000..f9e639f
--- /dev/null
+++ b/src/components/TemplateBrowser.tsx
@@ -0,0 +1,485 @@
+import { useState } from 'react'
+import { tripTemplates, getTemplatesByCategory, getRecommendedTemplates, TripTemplate } from '../data/tripTemplates'
+import { TripCategories } from '../services/tripManager'
+import { tripManagerService } from '../services/tripManager'
+
+interface TemplateBrowserProps {
+  onTemplateSelect?: (template: TripTemplate) => void
+  onClose?: () => void
+  className?: string
+}
+
+const TemplateBrowser = ({ onTemplateSelect, onClose, className = '' }: TemplateBrowserProps) => {
+  const [selectedCategory, setSelectedCategory] = useState<string>('all')
+  const [selectedTemplate, setSelectedTemplate] = useState<TripTemplate | null>(null)
+  const [isCreating, setIsCreating] = useState(false)
+
+  const getFilteredTemplates = () => {
+    if (selectedCategory === 'all') {
+      return tripTemplates
+    } else if (selectedCategory === 'recommended') {
+      return getRecommendedTemplates()
+    } else {
+      return getTemplatesByCategory(selectedCategory)
+    }
+  }
+
+  const handleCreateFromTemplate = async (template: TripTemplate, customDates?: { startDate: Date; endDate: Date }) => {
+    setIsCreating(true)
+
+    try {
+      // 템플릿을 기반으로 새 여행 계획 생성
+      const startDate = customDates?.startDate || new Date()
+      const endDate = customDates?.endDate || new Date(Date.now() + (template.duration - 1) * 24 * 60 * 60 * 1000)
+
+      const result = await tripManagerService.createTrip({
+        title: template.title,
+        description: template.description,
+        destination: template.destination,
+        startDate,
+        endDate,
+        template_category: template.category,
+        tags: template.tags,
+        is_public: false
+      })
+
+      if (result.success && result.trip) {
+        // 템플릿의 샘플 일정을 새 여행에 적용
+        const updatedTrip = {
+          ...result.trip,
+          schedule: template.sample_schedule.map((day, index) => ({
+            ...day,
+            date: new Date(startDate.getTime() + index * 24 * 60 * 60 * 1000)
+          }))
+        }
+
+        await tripManagerService.updateTrip(result.trip.id, updatedTrip)
+        
+        alert(`"${template.title}" 템플릿으로 여행 계획이 생성되었습니다!`)
+        
+        if (onTemplateSelect) {
+          onTemplateSelect(template)
+        }
+        if (onClose) {
+          onClose()
+        }
+      } else {
+        alert(result.message || '템플릿 적용 중 오류가 발생했습니다')
+      }
+    } catch (error) {
+      alert('템플릿 적용 중 오류가 발생했습니다')
+    } finally {
+      setIsCreating(false)
+    }
+  }
+
+  const formatBudget = (template: TripTemplate) => {
+    const { min, max, currency } = template.budget_range
+    const symbol = currency === 'KRW' ? '₩' : currency === 'JPY' ? '¥' : '$'
+    
+    if (currency === 'KRW') {
+      return `${symbol}${(min / 10000).toFixed(0)}-${(max / 10000).toFixed(0)}만원`
+    } else {
+      return `${symbol}${min.toLocaleString()}-${max.toLocaleString()}`
+    }
+  }
+
+  const getDifficultyInfo = (difficulty: string) => {
+    const difficultyMap = {
+      easy: { label: '쉬움', color: 'bg-green-100 text-green-800', icon: '😊' },
+      medium: { label: '보통', color: 'bg-yellow-100 text-yellow-800', icon: '🙂' },
+      hard: { label: '어려움', color: 'bg-red-100 text-red-800', icon: '😅' }
+    }
+    return difficultyMap[difficulty as keyof typeof difficultyMap] || difficultyMap.medium
+  }
+
+  const filteredTemplates = getFilteredTemplates()
+
+  return (
+    <div className={`bg-white rounded-lg shadow-xl ${className}`}>
+      {/* 헤더 */}
+      <div className="p-6 border-b border-gray-200">
+        <div className="flex items-center justify-between">
+          <div>
+            <h2 className="text-2xl font-bold text-gray-800">🌟 여행 템플릿</h2>
+            <p className="text-gray-600 mt-1">검증된 여행 코스로 쉽고 빠르게 계획을 세워보세요</p>
+          </div>
+          {onClose && (
+            <button
+              onClick={onClose}
+              className="text-gray-400 hover:text-gray-600 text-2xl"
+            >
+              ×
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* 카테고리 필터 */}
+      <div className="p-6 border-b border-gray-200">
+        <div className="flex flex-wrap gap-2">
+          <button
+            onClick={() => setSelectedCategory('all')}
+            className={`px-4 py-2 rounded-full text-sm font-medium transition-colors ${
+              selectedCategory === 'all'
+                ? 'bg-blue-600 text-white'
+                : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+            }`}
+          >
+            🌍 전체
+          </button>
+          <button
+            onClick={() => setSelectedCategory('recommended')}
+            className={`px-4 py-2 rounded-full text-sm font-medium transition-colors ${
+              selectedCategory === 'recommended'
+                ? 'bg-blue-600 text-white'
+                : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+            }`}
+          >
+            ⭐ 추천
+          </button>
+          {Object.entries(TripCategories).map(([key, category]) => (
+            <button
+              key={key}
+              onClick={() => setSelectedCategory(key)}
+              className={`px-4 py-2 rounded-full text-sm font-medium transition-colors ${
+                selectedCategory === key
+                  ? 'bg-blue-600 text-white'
+                  : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+              }`}
+            >
+              {category.label}
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 템플릿 목록 */}
+      <div className="p-6">
+        {filteredTemplates.length === 0 ? (
+          <div className="text-center py-12">
+            <div className="text-4xl mb-4">🔍</div>
+            <div className="text-lg font-medium text-gray-800 mb-2">
+              해당 카테고리의 템플릿이 없습니다
+            </div>
+            <div className="text-gray-600">
+              다른 카테고리를 선택해보세요
+            </div>
+          </div>
+        ) : (
+          <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
+            {filteredTemplates.map((template) => {
+              const difficultyInfo = getDifficultyInfo(template.difficulty)
+              
+              return (
+                <div
+                  key={template.id}
+                  className="border border-gray-200 rounded-lg overflow-hidden hover:shadow-lg transition-shadow cursor-pointer"
+                  onClick={() => setSelectedTemplate(template)}
+                >
+                  {/* 템플릿 이미지 */}
+                  <div className="relative h-48 bg-gray-200">
+                    <img
+                      src={template.thumbnail}
+                      alt={template.title}
+                      className="w-full h-full object-cover"
+                    />
+                    <div className="absolute top-3 left-3">
+                      <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${
+                        TripCategories[template.category]?.color || 'bg-gray-100 text-gray-800'
+                      }`}>
+                        {TripCategories[template.category]?.label || template.category}
+                      </span>
+                    </div>
+                    <div className="absolute top-3 right-3">
+                      <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${difficultyInfo.color}`}>
+                        {difficultyInfo.icon} {difficultyInfo.label}
+                      </span>
+                    </div>
+                  </div>
+
+                  {/* 템플릿 정보 */}
+                  <div className="p-4">
+                    <h3 className="text-lg font-semibold text-gray-800 mb-2">
+                      {template.title}
+                    </h3>
+                    <p className="text-gray-600 text-sm mb-3 line-clamp-2">
+                      {template.description}
+                    </p>
+
+                    <div className="space-y-2 text-sm">
+                      <div className="flex items-center justify-between">
+                        <span className="text-gray-500">📍 위치</span>
+                        <span className="font-medium">
+                          {template.destination.city}, {template.destination.country}
+                        </span>
+                      </div>
+                      <div className="flex items-center justify-between">
+                        <span className="text-gray-500">⏱️ 기간</span>
+                        <span className="font-medium">{template.duration}일</span>
+                      </div>
+                      <div className="flex items-center justify-between">
+                        <span className="text-gray-500">💰 예산</span>
+                        <span className="font-medium">{formatBudget(template)}</span>
+                      </div>
+                      <div className="flex items-center justify-between">
+                        <span className="text-gray-500">🌸 최적 시기</span>
+                        <span className="font-medium text-xs">{template.best_time}</span>
+                      </div>
+                    </div>
+
+                    {/* 태그 */}
+                    <div className="mt-3 flex flex-wrap gap-1">
+                      {template.tags.slice(0, 3).map((tag) => (
+                        <span
+                          key={tag}
+                          className="inline-block px-2 py-1 bg-gray-100 text-gray-600 text-xs rounded"
+                        >
+                          #{tag}
+                        </span>
+                      ))}
+                      {template.tags.length > 3 && (
+                        <span className="inline-block px-2 py-1 bg-gray-100 text-gray-600 text-xs rounded">
+                          +{template.tags.length - 3}
+                        </span>
+                      )}
+                    </div>
+                  </div>
+                </div>
+              )
+            })}
+          </div>
+        )}
+      </div>
+
+      {/* 템플릿 상세 모달 */}
+      {selectedTemplate && (
+        <TemplateDetailModal
+          template={selectedTemplate}
+          onClose={() => setSelectedTemplate(null)}
+          onCreateFromTemplate={handleCreateFromTemplate}
+          isCreating={isCreating}
+        />
+      )}
+    </div>
+  )
+}
+
+// 템플릿 상세 모달
+const TemplateDetailModal = ({
+  template,
+  onClose,
+  onCreateFromTemplate,
+  isCreating
+}: {
+  template: TripTemplate
+  onClose: () => void
+  onCreateFromTemplate: (template: TripTemplate, dates?: { startDate: Date; endDate: Date }) => void
+  isCreating: boolean
+}) => {
+  const [customDates, setCustomDates] = useState({
+    startDate: new Date(),
+    endDate: new Date(Date.now() + (template.duration - 1) * 24 * 60 * 60 * 1000)
+  })
+
+  const difficultyInfo = getDifficultyInfo(template.difficulty)
+
+  const formatBudget = (template: TripTemplate) => {
+    const { min, max, currency } = template.budget_range
+    const symbol = currency === 'KRW' ? '₩' : currency === 'JPY' ? '¥' : '$'
+    
+    if (currency === 'KRW') {
+      return `${symbol}${(min / 10000).toFixed(0)}-${(max / 10000).toFixed(0)}만원`
+    } else {
+      return `${symbol}${min.toLocaleString()}-${max.toLocaleString()}`
+    }
+  }
+
+  const getDifficultyInfo = (difficulty: string) => {
+    const difficultyMap = {
+      easy: { label: '쉬움', color: 'bg-green-100 text-green-800', icon: '😊' },
+      medium: { label: '보통', color: 'bg-yellow-100 text-yellow-800', icon: '🙂' },
+      hard: { label: '어려움', color: 'bg-red-100 text-red-800', icon: '😅' }
+    }
+    return difficultyMap[difficulty as keyof typeof difficultyMap] || difficultyMap.medium
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
+      <div className="bg-white rounded-lg w-full max-w-4xl max-h-[90vh] overflow-y-auto">
+        {/* 헤더 */}
+        <div className="relative">
+          <img
+            src={template.thumbnail}
+            alt={template.title}
+            className="w-full h-64 object-cover"
+          />
+          <div className="absolute inset-0 bg-black bg-opacity-40"></div>
+          <div className="absolute bottom-4 left-4 text-white">
+            <h2 className="text-3xl font-bold mb-2">{template.title}</h2>
+            <p className="text-lg opacity-90">{template.description}</p>
+          </div>
+          <button
+            onClick={onClose}
+            className="absolute top-4 right-4 text-white hover:text-gray-300 text-2xl bg-black bg-opacity-50 rounded-full w-8 h-8 flex items-center justify-center"
+          >
+            ×
+          </button>
+        </div>
+
+        <div className="p-6">
+          {/* 기본 정보 */}
+          <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
+            <div className="text-center p-4 bg-gray-50 rounded-lg">
+              <div className="text-2xl font-bold text-blue-600">{template.duration}일</div>
+              <div className="text-sm text-gray-600">여행 기간</div>
+            </div>
+            <div className="text-center p-4 bg-gray-50 rounded-lg">
+              <div className="text-lg font-bold text-green-600">{formatBudget(template)}</div>
+              <div className="text-sm text-gray-600">예상 예산</div>
+            </div>
+            <div className="text-center p-4 bg-gray-50 rounded-lg">
+              <div className={`inline-flex items-center px-3 py-1 rounded-full text-sm font-medium ${difficultyInfo.color}`}>
+                {difficultyInfo.icon} {difficultyInfo.label}
+              </div>
+              <div className="text-sm text-gray-600 mt-1">난이도</div>
+            </div>
+            <div className="text-center p-4 bg-gray-50 rounded-lg">
+              <div className="text-sm font-bold text-purple-600">{template.best_time}</div>
+              <div className="text-sm text-gray-600">최적 시기</div>
+            </div>
+          </div>
+
+          {/* 주요 볼거리 */}
+          <div className="mb-6">
+            <h3 className="text-lg font-semibold text-gray-800 mb-3">🎯 주요 볼거리</h3>
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
+              {template.highlights.map((highlight, index) => (
+                <div key={index} className="flex items-start gap-3 p-3 bg-blue-50 rounded-lg">
+                  <div className="w-6 h-6 bg-blue-600 text-white rounded-full flex items-center justify-center text-sm font-bold flex-shrink-0">
+                    {index + 1}
+                  </div>
+                  <div className="text-sm text-blue-800">{highlight}</div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {/* 샘플 일정 */}
+          <div className="mb-6">
+            <h3 className="text-lg font-semibold text-gray-800 mb-3">📅 샘플 일정</h3>
+            <div className="space-y-4">
+              {template.sample_schedule.map((day, dayIndex) => (
+                <div key={dayIndex} className="border border-gray-200 rounded-lg p-4">
+                  <h4 className="font-medium text-gray-800 mb-3">
+                    Day {dayIndex + 1} ({day.activities.length}개 일정)
+                  </h4>
+                  <div className="space-y-2">
+                    {day.activities.map((activity, actIndex) => (
+                      <div key={actIndex} className="flex items-center gap-3 text-sm">
+                        <span className="text-blue-600 font-medium w-12">{activity.time}</span>
+                        <span className="flex-1">{activity.title}</span>
+                        <span className="text-gray-500 text-xs">{activity.type}</span>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              ))}
+            </div>
+          </div>
+
+          {/* 여행 팁 */}
+          <div className="mb-6">
+            <h3 className="text-lg font-semibold text-gray-800 mb-3">💡 여행 팁</h3>
+            <div className="bg-yellow-50 border border-yellow-200 rounded-lg p-4">
+              <ul className="space-y-2">
+                {template.tips.map((tip, index) => (
+                  <li key={index} className="flex items-start gap-2 text-sm text-yellow-800">
+                    <span className="text-yellow-600 mt-0.5">•</span>
+                    <span>{tip}</span>
+                  </li>
+                ))}
+              </ul>
+            </div>
+          </div>
+
+          {/* 태그 */}
+          <div className="mb-6">
+            <h3 className="text-lg font-semibold text-gray-800 mb-3">🏷️ 태그</h3>
+            <div className="flex flex-wrap gap-2">
+              {template.tags.map((tag) => (
+                <span
+                  key={tag}
+                  className="inline-block px-3 py-1 bg-gray-100 text-gray-700 text-sm rounded-full"
+                >
+                  #{tag}
+                </span>
+              ))}
+            </div>
+          </div>
+
+          {/* 날짜 선택 및 생성 버튼 */}
+          <div className="border-t border-gray-200 pt-6">
+            <h3 className="text-lg font-semibold text-gray-800 mb-4">📅 여행 날짜 선택</h3>
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mb-6">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  출발일
+                </label>
+                <input
+                  type="date"
+                  value={customDates.startDate.toISOString().split('T')[0]}
+                  onChange={(e) => setCustomDates({
+                    ...customDates,
+                    startDate: new Date(e.target.value)
+                  })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                />
+              </div>
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  도착일
+                </label>
+                <input
+                  type="date"
+                  value={customDates.endDate.toISOString().split('T')[0]}
+                  onChange={(e) => setCustomDates({
+                    ...customDates,
+                    endDate: new Date(e.target.value)
+                  })}
+                  min={customDates.startDate.toISOString().split('T')[0]}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                />
+              </div>
+            </div>
+
+            <div className="flex gap-3">
+              <button
+                onClick={onClose}
+                className="flex-1 px-6 py-3 border border-gray-300 text-gray-700 rounded-lg hover:bg-gray-50"
+              >
+                취소
+              </button>
+              <button
+                onClick={() => onCreateFromTemplate(template, customDates)}
+                disabled={isCreating}
+                className="flex-1 px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 disabled:opacity-50"
+              >
+                {isCreating ? (
+                  <div className="flex items-center justify-center gap-2">
+                    <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                    생성 중...
+                  </div>
+                ) : (
+                  '🚀 이 템플릿으로 여행 만들기'
+                )}
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default TemplateBrowser
diff --git a/src/components/Timeline.tsx b/src/components/Timeline.tsx
index efeebd8..c4c38fa 100644
--- a/src/components/Timeline.tsx
+++ b/src/components/Timeline.tsx
@@ -1,6 +1,11 @@
 import { format, eachDayOfInterval } from 'date-fns'
-import { TravelPlan, Activity } from '../types'
+import { TravelPlan, Activity, RelatedPlace } from '../types'
 import { useState } from 'react'
+import RelatedPlacesManager from './RelatedPlacesManager'
+import ActivityEditor from './ActivityEditor'
+import LocationSelector from './forms/LocationSelector'
+// import RouteOptimizer from './RouteOptimizer' // 임시 비활성화
+import { OptimizedItinerary } from '../services/googleDirections'
 
 interface TimelineProps {
   travelPlan: TravelPlan
@@ -13,6 +18,7 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
     end: travelPlan.endDate,
   })
 
+  const [currentDayIndex, setCurrentDayIndex] = useState(0)
   const [selectedDay, setSelectedDay] = useState<Date | null>(null)
   const [editingTime, setEditingTime] = useState<string | null>(null)
   const [editingTimeValue, setEditingTimeValue] = useState('')
@@ -23,9 +29,28 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
     location: '',
     type: 'other',
   })
+  const [showRouteOptimizer, setShowRouteOptimizer] = useState(false)
+
+  const [customCoordinates, setCustomCoordinates] = useState<{ lat: number; lng: number } | null>(null)
+
+  // 관련 장소 관리 모달
+  const [managingActivity, setManagingActivity] = useState<Activity | null>(null)
+
+  // 일정 편집 모달
+  const [editingActivity, setEditingActivity] = useState<Activity | null>(null)
 
   const addActivity = (date: Date) => {
-    if (!newActivity.time || !newActivity.title) return
+    if (!newActivity.time || !newActivity.title) {
+      alert('시간과 제목을 입력해주세요!')
+      return
+    }
+
+    // 좌표가 유효한지 확인 (0이 아닌 값이 있어야 함)
+    const validCoordinates = customCoordinates &&
+      customCoordinates.lat !== 0 &&
+      customCoordinates.lng !== 0
+      ? customCoordinates
+      : undefined
 
     const activity: Activity = {
       id: Date.now().toString(),
@@ -34,6 +59,7 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
       description: newActivity.description,
       location: newActivity.location,
       type: newActivity.type as Activity['type'],
+      coordinates: validCoordinates,
     }
 
     const updatedSchedule = [...travelPlan.schedule]
@@ -65,6 +91,7 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
       location: '',
       type: 'other',
     })
+    setCustomCoordinates(null)
     setSelectedDay(null)
   }
 
@@ -77,9 +104,13 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
   }
 
   const getDayLabel = (date: Date, index: number) => {
-    const dayNames = ['월', '화', '수', '목', '금', '토', '일']
+    const dayNames = ['일', '월', '화', '수', '목', '금', '토']
     const dayName = dayNames[date.getDay()]
-    return `${index + 1}일차 (${dayName})`
+    return `${index + 1}일차 ${dayName}요일`
+  }
+
+  const formatDateShort = (date: Date) => {
+    return format(date, 'M월 d일')
   }
 
   const updateActivityTime = (activityId: string, newTime: string) => {
@@ -104,7 +135,11 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
     setEditingTime(null)
   }
 
-  const deleteActivity = (activityId: string) => {
+  const deleteActivity = (activityId: string, activityTitle: string) => {
+    if (!confirm(`"${activityTitle}" 일정을 삭제하시겠습니까?\n\n⚠️ 삭제된 일정은 복구할 수 없습니다.`)) {
+      return
+    }
+
     const updatedSchedule = travelPlan.schedule.map((daySchedule) => ({
       ...daySchedule,
       activities: daySchedule.activities.filter(
@@ -118,190 +153,348 @@ const Timeline = ({ travelPlan, setTravelPlan }: TimelineProps) => {
     })
   }
 
+  // 경로 최적화 결과 처리
+  const handleOptimizedRoute = (optimizedItinerary: OptimizedItinerary) => {
+    console.log('Optimized route:', optimizedItinerary)
+    // 최적화 결과를 사용자에게 보여주기 위해 상태에 저장
+  }
+
+  // 최적화된 순서 적용
+  const handleApplyOptimization = (optimizedActivities: any[]) => {
+    if (!selectedDay) return
+
+    const dayKey = format(selectedDay, 'yyyy-MM-dd')
+    const updatedSchedule = travelPlan.schedule.map((daySchedule) => {
+      if (format(daySchedule.date, 'yyyy-MM-dd') === dayKey) {
+        return {
+          ...daySchedule,
+          activities: optimizedActivities
+        }
+      }
+      return daySchedule
+    })
+
+    setTravelPlan({
+      ...travelPlan,
+      schedule: updatedSchedule,
+    })
+
+    setShowRouteOptimizer(false)
+    alert('경로가 최적화되었습니다! 🎉')
+  }
+
   const startEditTime = (activityId: string, currentTime: string) => {
     setEditingTime(activityId)
     setEditingTimeValue(currentTime)
   }
 
+  // 관련 장소 업데이트
+  const updateRelatedPlaces = (activityId: string, relatedPlaces: RelatedPlace[]) => {
+    const updatedSchedule = travelPlan.schedule.map((daySchedule) => ({
+      ...daySchedule,
+      activities: daySchedule.activities.map((activity) =>
+        activity.id === activityId
+          ? { ...activity, relatedPlaces }
+          : activity
+      ),
+    }))
+
+    setTravelPlan({
+      ...travelPlan,
+      schedule: updatedSchedule,
+    })
+  }
+
+  // 일정 업데이트
+  const updateActivity = (updatedActivity: Activity) => {
+    const updatedSchedule = travelPlan.schedule.map((daySchedule) => ({
+      ...daySchedule,
+      activities: daySchedule.activities.map((activity) =>
+        activity.id === updatedActivity.id
+          ? updatedActivity
+          : activity
+      ),
+    }))
+
+    // 시간 순으로 다시 정렬
+    updatedSchedule.forEach((daySchedule) => {
+      daySchedule.activities.sort((a, b) => a.time.localeCompare(b.time))
+    })
+
+    setTravelPlan({
+      ...travelPlan,
+      schedule: updatedSchedule,
+    })
+  }
+
+  const currentDay = days[currentDayIndex]
+  const activities = getDaySchedule(currentDay)
+  const isAddingActivity = selectedDay?.getTime() === currentDay.getTime()
+
   return (
-    <div className="bg-white rounded-lg shadow-md p-6">
-      <h2 className="text-2xl font-bold text-gray-800 mb-6">📅 여행 일정</h2>
+    <div className="p-6">
+      {/* 헤더는 부모 컴포넌트에서 처리 */}
 
-      <div className="space-y-6">
-        {days.map((day, index) => {
-          const activities = getDaySchedule(day)
-          const isSelected = selectedDay?.getTime() === day.getTime()
+      {/* 날짜 탭 */}
+      <div className="flex gap-2 mb-6 overflow-x-auto pb-2">
+        {days.map((day, index) => (
+          <button
+            key={day.toISOString()}
+            onClick={() => {
+              setCurrentDayIndex(index)
+              setSelectedDay(null) // 탭 변경시 추가 폼 닫기
+            }}
+            className={`px-4 py-2 rounded-lg whitespace-nowrap transition-all ${
+              currentDayIndex === index
+                ? 'bg-kumamoto-blue text-white shadow-md'
+                : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+            }`}
+          >
+            <div className="font-semibold">{formatDateShort(day)}</div>
+            <div className="text-xs mt-0.5">{getDayLabel(day, index)}</div>
+          </button>
+        ))}
+      </div>
 
-          return (
-            <div
-              key={day.toISOString()}
-              className="border-l-4 border-kumamoto-blue pl-4"
+      {/* 현재 선택된 날짜의 일정 */}
+      <div className="border-l-4 border-kumamoto-blue pl-4">
+        <div className="flex items-center justify-between mb-4">
+          <h3 className="text-xl font-semibold text-gray-800">
+            {format(currentDay, 'yyyy년 M월 d일')} {getDayLabel(currentDay, currentDayIndex)}
+          </h3>
+          <div className="flex gap-2">
+            {/* 경로 최적화 버튼 */}
+            {activities.length >= 2 && (
+              <button
+                onClick={() => {
+                  setSelectedDay(currentDay)
+                  setShowRouteOptimizer(!showRouteOptimizer)
+                }}
+                className={`px-3 py-2 text-sm rounded transition-colors ${
+                  showRouteOptimizer
+                    ? 'bg-green-600 text-white'
+                    : 'bg-green-100 text-green-700 hover:bg-green-200'
+                }`}
+              >
+                🗺️ 경로 최적화
+              </button>
+            )}
+            <button
+              onClick={() => setSelectedDay(isAddingActivity ? null : currentDay)}
+              className="px-4 py-2 bg-kumamoto-blue text-white rounded hover:bg-opacity-90 text-sm"
             >
-              <div className="flex items-center justify-between mb-3">
-                <div>
-                  <h3 className="text-lg font-semibold text-gray-800">
-                    {format(day, 'yyyy년 M월 d일')} ({getDayLabel(day, index)})
-                  </h3>
-                </div>
-                <button
-                  onClick={() => setSelectedDay(isSelected ? null : day)}
-                  className="px-3 py-1 bg-kumamoto-blue text-white rounded hover:bg-opacity-90 text-sm"
-                >
-                  {isSelected ? '취소' : '+ 일정 추가'}
-                </button>
-              </div>
+              {isAddingActivity ? '취소' : '+ 일정 추가'}
+            </button>
+          </div>
+        </div>
 
-              {isSelected && (
-                <div className="mb-4 p-4 bg-gray-50 rounded-lg space-y-3">
-                  <input
-                    type="time"
-                    value={newActivity.time}
-                    onChange={(e) =>
-                      setNewActivity({ ...newActivity, time: e.target.value })
-                    }
-                    className="w-full px-3 py-2 border rounded"
-                    placeholder="시간"
-                  />
-                  <input
-                    type="text"
-                    value={newActivity.title}
-                    onChange={(e) =>
-                      setNewActivity({ ...newActivity, title: e.target.value })
-                    }
-                    className="w-full px-3 py-2 border rounded"
-                    placeholder="일정 제목"
-                  />
-                  <input
-                    type="text"
-                    value={newActivity.location}
-                    onChange={(e) =>
-                      setNewActivity({
-                        ...newActivity,
-                        location: e.target.value,
-                      })
-                    }
-                    className="w-full px-3 py-2 border rounded"
-                    placeholder="장소 (선택)"
-                  />
-                  <textarea
-                    value={newActivity.description}
-                    onChange={(e) =>
-                      setNewActivity({
-                        ...newActivity,
-                        description: e.target.value,
-                      })
-                    }
-                    className="w-full px-3 py-2 border rounded"
-                    placeholder="설명 (선택)"
-                    rows={2}
-                  />
-                  <select
-                    value={newActivity.type}
-                    onChange={(e) =>
-                      setNewActivity({
-                        ...newActivity,
-                        type: e.target.value as Activity['type'],
-                      })
-                    }
-                    className="w-full px-3 py-2 border rounded"
-                  >
-                    <option value="attraction">관광지</option>
-                    <option value="food">식사</option>
-                    <option value="accommodation">숙소</option>
-                    <option value="transport">교통</option>
-                    <option value="other">기타</option>
-                  </select>
-                  <button
-                    onClick={() => addActivity(day)}
-                    className="w-full px-4 py-2 bg-kumamoto-green text-white rounded hover:bg-opacity-90"
-                  >
-                    추가하기
-                  </button>
-                </div>
-              )}
+        {isAddingActivity && (
+          <div className="mb-4 p-4 bg-gray-50 rounded-lg space-y-3">
+            <input
+              type="time"
+              value={newActivity.time}
+              onChange={(e) =>
+                setNewActivity({ ...newActivity, time: e.target.value })
+              }
+              className="w-full px-3 py-2 border rounded"
+              placeholder="시간"
+            />
+            <input
+              type="text"
+              value={newActivity.title}
+              onChange={(e) =>
+                setNewActivity({ ...newActivity, title: e.target.value })
+              }
+              className="w-full px-3 py-2 border rounded"
+              placeholder="일정 제목"
+            />
 
-              {activities.length > 0 ? (
-                <div className="space-y-2">
-                  {activities.map((activity) => (
-                    <div
-                      key={activity.id}
-                      className="bg-gray-50 p-3 rounded-lg flex items-start gap-3 group"
-                    >
-                      {editingTime === activity.id ? (
-                        <div className="min-w-[80px]">
-                          <input
-                            type="time"
-                            value={editingTimeValue}
-                            onChange={(e) => setEditingTimeValue(e.target.value)}
-                            onBlur={() => updateActivityTime(activity.id, editingTimeValue)}
-                            onKeyDown={(e) => {
-                              if (e.key === 'Enter') {
-                                updateActivityTime(activity.id, editingTimeValue)
-                              } else if (e.key === 'Escape') {
-                                setEditingTime(null)
-                              }
-                            }}
-                            className="w-full px-2 py-1 border border-kumamoto-blue rounded text-sm font-semibold text-kumamoto-blue"
-                            autoFocus
-                          />
-                        </div>
-                      ) : (
-                        <div
-                          className="font-semibold text-kumamoto-blue min-w-[60px] cursor-pointer hover:text-kumamoto-green transition-colors"
-                          onClick={() => startEditTime(activity.id, activity.time)}
-                          title="시간을 클릭하여 수정"
-                        >
-                          {activity.time}
-                        </div>
-                      )}
-                      <div className="flex-1">
-                        <div className="font-medium text-gray-800">
-                          {activity.title}
-                        </div>
-                        {activity.location && (
-                          <div className="text-sm text-gray-600">
-                            📍 {activity.location}
-                          </div>
-                        )}
-                        {activity.description && (
-                          <div className="text-sm text-gray-500 mt-1">
-                            {activity.description}
-                          </div>
-                        )}
-                        <div className="flex items-center gap-2 mt-1">
-                          <span className="inline-block px-2 py-0.5 bg-kumamoto-light text-xs rounded">
-                            {activity.type === 'attraction'
-                              ? '관광지'
-                              : activity.type === 'food'
-                              ? '식사'
-                              : activity.type === 'accommodation'
-                              ? '숙소'
-                              : activity.type === 'transport'
-                              ? '교통'
-                              : '기타'}
-                          </span>
-                          <button
-                            onClick={() => deleteActivity(activity.id)}
-                            className="opacity-0 group-hover:opacity-100 text-red-500 hover:text-red-700 text-xs transition-opacity"
-                            title="일정 삭제"
-                          >
-                            삭제
-                          </button>
-                        </div>
-                      </div>
-                    </div>
-                  ))}
-                </div>
-              ) : (
-                <p className="text-gray-400 text-sm">아직 일정이 없습니다.</p>
-              )}
+            {/* 장소/좌표 입력 섹션 - LocationSelector 사용 */}
+            <div className="border border-gray-300 rounded p-3 bg-white">
+              <LocationSelector
+                location={newActivity.location}
+                coordinates={customCoordinates}
+                onLocationChange={(location) => setNewActivity({ ...newActivity, location })}
+                onCoordinatesChange={setCustomCoordinates}
+              />
             </div>
-          )
-        })}
+
+            <textarea
+              value={newActivity.description}
+              onChange={(e) =>
+                setNewActivity({
+                  ...newActivity,
+                  description: e.target.value,
+                })
+              }
+              className="w-full px-3 py-2 border rounded"
+              placeholder="설명 (선택)"
+              rows={2}
+            />
+            <select
+              value={newActivity.type}
+              onChange={(e) =>
+                setNewActivity({
+                  ...newActivity,
+                  type: e.target.value as Activity['type'],
+                })
+              }
+              className="w-full px-3 py-2 border rounded"
+            >
+              <option value="attraction">관광지</option>
+              <option value="food">식사</option>
+              <option value="accommodation">숙소</option>
+              <option value="transport">교통</option>
+              <option value="other">기타</option>
+            </select>
+            <button
+              onClick={() => addActivity(currentDay)}
+              className="w-full px-4 py-2 bg-kumamoto-green text-white rounded hover:bg-opacity-90"
+            >
+              추가하기
+            </button>
+          </div>
+        )}
+
+        {/* 경로 최적화 패널 */}
+        {/* 임시 비활성화 - Google Maps API 이슈로 인해
+        {showRouteOptimizer && selectedDay && (
+          <div className="mb-4">
+            <RouteOptimizer
+              activities={activities}
+              onOptimizedRoute={handleOptimizedRoute}
+              onApplyOptimization={handleApplyOptimization}
+            />
+          </div>
+        )
+        */}
+
+        {activities.length > 0 ? (
+          <div className="space-y-2">
+            {activities.map((activity) => {
+              const hasRelatedPlaces = activity.relatedPlaces && activity.relatedPlaces.length > 0
+
+              return (
+                <div
+                  key={activity.id}
+                  className="bg-gray-50 p-2 rounded-lg flex items-start gap-2 group hover:bg-gray-100 cursor-pointer transition-colors text-sm"
+                  onClick={() => setEditingActivity(activity)}
+                >
+                  {editingTime === activity.id ? (
+                    <div className="min-w-[80px]">
+                      <input
+                        type="time"
+                        value={editingTimeValue}
+                        onChange={(e) => setEditingTimeValue(e.target.value)}
+                        onBlur={() => updateActivityTime(activity.id, editingTimeValue)}
+                        onKeyDown={(e) => {
+                          if (e.key === 'Enter') {
+                            updateActivityTime(activity.id, editingTimeValue)
+                          } else if (e.key === 'Escape') {
+                            setEditingTime(null)
+                          }
+                        }}
+                        className="w-full px-2 py-1 border border-kumamoto-blue rounded text-sm font-semibold text-kumamoto-blue"
+                        autoFocus
+                      />
+                    </div>
+                  ) : (
+                    <div
+                      className="font-semibold text-kumamoto-blue min-w-[60px] cursor-pointer hover:text-kumamoto-green transition-colors"
+                      onClick={(e) => {
+                        e.stopPropagation()
+                        startEditTime(activity.id, activity.time)
+                      }}
+                      title="시간을 클릭하여 수정"
+                    >
+                      {activity.time}
+                    </div>
+                  )}
+                  <div className="flex-1">
+                    <div className="font-medium text-gray-800">
+                      {activity.title}
+                      {hasRelatedPlaces && (
+                        <span className="ml-2 text-xs bg-green-100 text-green-700 px-2 py-0.5 rounded">
+                          +{activity.relatedPlaces?.length}
+                        </span>
+                      )}
+                    </div>
+                    {activity.location && (
+                      <div className="text-sm text-gray-600">
+                        📍 {activity.location}
+                      </div>
+                    )}
+                    {activity.coordinates && (
+                      <div className="text-xs text-purple-600">
+                        🗺️ 지도 핀: {activity.coordinates.lat.toFixed(4)}, {activity.coordinates.lng.toFixed(4)}
+                      </div>
+                    )}
+                    {activity.description && (
+                      <div className="text-sm text-gray-500 mt-1">
+                        {activity.description}
+                      </div>
+                    )}
+                    <div className="flex items-center gap-2 mt-1">
+                      <span className="inline-block px-2 py-0.5 bg-kumamoto-light text-xs rounded">
+                        {activity.type === 'attraction'
+                          ? '관광지'
+                          : activity.type === 'food'
+                          ? '식사'
+                          : activity.type === 'accommodation'
+                          ? '숙소'
+                          : activity.type === 'transport'
+                          ? '교통'
+                          : '기타'}
+                      </span>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          setManagingActivity(activity)
+                        }}
+                        className="px-2 py-0.5 bg-blue-100 text-blue-700 hover:bg-blue-200 text-xs rounded transition-colors"
+                      >
+                        🏞️ 주변 관광지 ({activity.relatedPlaces?.length || 0})
+                      </button>
+                      <button
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          deleteActivity(activity.id, activity.title)
+                        }}
+                        className="opacity-0 group-hover:opacity-100 text-red-500 hover:text-red-700 text-xs transition-opacity"
+                        title="일정 삭제"
+                      >
+                        삭제
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              )
+            })}
+          </div>
+        ) : (
+          <p className="text-gray-400 text-sm">아직 일정이 없습니다.</p>
+        )}
+
+        {/* 관련 장소 관리 모달 */}
+        {managingActivity && (
+          <RelatedPlacesManager
+            activity={managingActivity}
+            onUpdate={updateRelatedPlaces}
+            onClose={() => setManagingActivity(null)}
+          />
+        )}
+
+        {/* 일정 편집 모달 */}
+        {editingActivity && (
+          <ActivityEditor
+            activity={editingActivity}
+            onUpdate={updateActivity}
+            onClose={() => setEditingActivity(null)}
+          />
+        )}
       </div>
     </div>
   )
 }
 
 export default Timeline
-
diff --git a/src/components/TravelDashboard.tsx b/src/components/TravelDashboard.tsx
new file mode 100644
index 0000000..69dc3e8
--- /dev/null
+++ b/src/components/TravelDashboard.tsx
@@ -0,0 +1,136 @@
+import { TravelPlan } from '../types'
+
+interface TravelDashboardProps {
+  travelPlan: TravelPlan
+}
+
+const TravelDashboard = ({ travelPlan }: TravelDashboardProps) => {
+  // 진행률 계산
+  const totalActivities = travelPlan.schedule.reduce((sum, day) => sum + day.activities.length, 0)
+  const completedActivities = 0 // TODO: 완료된 활동 수 계산
+  const progressPercentage = totalActivities > 0 ? Math.round((completedActivities / totalActivities) * 100) : 0
+
+  // 예산 계산
+  const totalBudget = Object.values(travelPlan.budget).reduce((sum, amount) => sum + amount, 0)
+  const budgetCategories = [
+    { name: '숙박', amount: travelPlan.budget.accommodation, color: 'bg-blue-500' },
+    { name: '식사', amount: travelPlan.budget.food, color: 'bg-green-500' },
+    { name: '교통', amount: travelPlan.budget.transportation, color: 'bg-yellow-500' },
+    { name: '쇼핑', amount: travelPlan.budget.shopping, color: 'bg-purple-500' },
+    { name: '활동', amount: travelPlan.budget.activities, color: 'bg-red-500' },
+  ]
+
+  // 여행 일수 계산
+  const startDate = new Date(travelPlan.startDate)
+  const endDate = new Date(travelPlan.endDate)
+  const tripDays = Math.ceil((endDate.getTime() - startDate.getTime()) / (1000 * 60 * 60 * 24)) + 1
+
+  // D-Day 계산
+  const today = new Date()
+  const dDay = Math.ceil((startDate.getTime() - today.getTime()) / (1000 * 60 * 60 * 24))
+
+  return (
+    <div className="bg-white rounded-lg shadow-md p-6 mb-6">
+      <div className="grid grid-cols-1 md:grid-cols-4 gap-6">
+        {/* 여행 개요 */}
+        <div className="md:col-span-2">
+          <h2 className="text-xl font-bold text-gray-800 mb-4">📋 여행 개요</h2>
+          <div className="space-y-3">
+            <div className="flex items-center justify-between">
+              <span className="text-gray-600">여행 기간</span>
+              <span className="font-medium">
+                {startDate.getMonth() + 1}월 {startDate.getDate()}일 ~ {endDate.getMonth() + 1}월 {endDate.getDate()}일 ({tripDays}일간)
+              </span>
+            </div>
+            <div className="flex items-center justify-between">
+              <span className="text-gray-600">D-Day</span>
+              <span className={`font-bold ${dDay > 0 ? 'text-blue-600' : dDay === 0 ? 'text-green-600' : 'text-gray-600'}`}>
+                {dDay > 0 ? `D-${dDay}` : dDay === 0 ? 'D-Day!' : '여행 중'}
+              </span>
+            </div>
+            <div className="flex items-center justify-between">
+              <span className="text-gray-600">총 일정</span>
+              <span className="font-medium">{totalActivities}개 활동</span>
+            </div>
+          </div>
+        </div>
+
+        {/* 진행률 */}
+        <div>
+          <h3 className="text-lg font-semibold text-gray-800 mb-4">📊 계획 진행률</h3>
+          <div className="text-center">
+            <div className="relative w-20 h-20 mx-auto mb-2">
+              <svg className="w-20 h-20 transform -rotate-90" viewBox="0 0 36 36">
+                <path
+                  className="text-gray-200"
+                  stroke="currentColor"
+                  strokeWidth="3"
+                  fill="none"
+                  d="M18 2.0845 a 15.9155 15.9155 0 0 1 0 31.831 a 15.9155 15.9155 0 0 1 0 -31.831"
+                />
+                <path
+                  className="text-kumamoto-primary"
+                  stroke="currentColor"
+                  strokeWidth="3"
+                  strokeDasharray={`${progressPercentage}, 100`}
+                  strokeLinecap="round"
+                  fill="none"
+                  d="M18 2.0845 a 15.9155 15.9155 0 0 1 0 31.831 a 15.9155 15.9155 0 0 1 0 -31.831"
+                />
+              </svg>
+              <div className="absolute inset-0 flex items-center justify-center">
+                <span className="text-lg font-bold text-gray-800">{progressPercentage}%</span>
+              </div>
+            </div>
+            <p className="text-sm text-gray-600">
+              {completedActivities}/{totalActivities} 완료
+            </p>
+          </div>
+        </div>
+
+        {/* 예산 요약 */}
+        <div>
+          <h3 className="text-lg font-semibold text-gray-800 mb-4">💰 예산 요약</h3>
+          <div className="space-y-2">
+            <div className="text-center mb-3">
+              <div className="text-2xl font-bold text-gray-800">
+                ¥{totalBudget.toLocaleString()}
+              </div>
+              <div className="text-sm text-gray-600">총 예산</div>
+            </div>
+            
+            {budgetCategories.map((category) => (
+              category.amount > 0 && (
+                <div key={category.name} className="flex items-center gap-2">
+                  <div className={`w-3 h-3 rounded ${category.color}`}></div>
+                  <span className="text-sm text-gray-600 flex-1">{category.name}</span>
+                  <span className="text-sm font-medium">¥{category.amount.toLocaleString()}</span>
+                </div>
+              )
+            ))}
+          </div>
+        </div>
+      </div>
+
+      {/* 빠른 액션 버튼들 */}
+      <div className="mt-6 pt-4 border-t border-gray-200">
+        <div className="flex flex-wrap gap-3">
+          <button className="px-4 py-2 bg-kumamoto-primary text-white rounded-lg hover:bg-opacity-90 transition-colors text-sm">
+            📱 모바일로 보기
+          </button>
+          <button className="px-4 py-2 bg-gray-100 text-gray-700 rounded-lg hover:bg-gray-200 transition-colors text-sm">
+            📤 계획 공유하기
+          </button>
+          <button className="px-4 py-2 bg-gray-100 text-gray-700 rounded-lg hover:bg-gray-200 transition-colors text-sm">
+            🌤️ 날씨 확인
+          </button>
+          <button className="px-4 py-2 bg-gray-100 text-gray-700 rounded-lg hover:bg-gray-200 transition-colors text-sm">
+            💾 백업 저장
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default TravelDashboard
diff --git a/src/components/TravelMap.tsx b/src/components/TravelMap.tsx
new file mode 100644
index 0000000..74a7291
--- /dev/null
+++ b/src/components/TravelMap.tsx
@@ -0,0 +1,535 @@
+import { useEffect, useState } from 'react'
+import { MapContainer, TileLayer, Marker, Popup } from 'react-leaflet'
+import { Icon } from 'leaflet'
+import { Attraction, BasePoint } from '../types'
+import { basePointsAPI } from '../services/api'
+import 'leaflet/dist/leaflet.css'
+
+interface TravelMapProps {
+  attractions: Attraction[]
+}
+
+interface SearchResult {
+  display_name: string
+  lat: string
+  lon: string
+}
+
+const TravelMap = ({ attractions }: TravelMapProps) => {
+  const [isMounted, setIsMounted] = useState(false)
+  const [mapError, setMapError] = useState<string | null>(null)
+  const [basePoints, setBasePoints] = useState<BasePoint[]>([])
+  const [showAddForm, setShowAddForm] = useState(false)
+
+  // 폼 상태
+  const [formData, setFormData] = useState({
+    name: '',
+    address: '',
+    type: 'accommodation' as BasePoint['type'],
+    memo: ''
+  })
+
+  const [searchResults, setSearchResults] = useState<SearchResult[]>([])
+  const [isSearching, setIsSearching] = useState(false)
+  const [selectedLocation, setSelectedLocation] = useState<{ lat: number; lng: number } | null>(null)
+
+  useEffect(() => {
+    // 클라이언트에서만 실행
+    if (typeof window !== 'undefined') {
+      setIsMounted(true)
+      // API에서 기본 포인트 불러오기
+      loadBasePoints()
+    }
+  }, [])
+
+  const loadBasePoints = async () => {
+    try {
+      const points = await basePointsAPI.getAll()
+      setBasePoints(points)
+    } catch (error) {
+      console.error('Failed to load base points:', error)
+    }
+  }
+
+
+  // 주소 검색 (Nominatim API)
+  const searchAddress = async (query: string) => {
+    if (!query.trim()) return
+
+    setIsSearching(true)
+    try {
+      // 구마모토 지역에 검색 제한
+      const response = await fetch(
+        `https://nominatim.openstreetmap.org/search?` +
+        `q=${encodeURIComponent(query + ' 熊本')}&` +
+        `format=json&` +
+        `limit=5&` +
+        `countrycodes=jp&` +
+        `accept-language=ja`
+      )
+      const data = await response.json()
+      setSearchResults(data)
+    } catch (error) {
+      console.error('Address search failed:', error)
+      alert('주소 검색에 실패했습니다.')
+    } finally {
+      setIsSearching(false)
+    }
+  }
+
+  // 검색 결과 선택
+  const selectSearchResult = (result: SearchResult) => {
+    setSelectedLocation({
+      lat: parseFloat(result.lat),
+      lng: parseFloat(result.lon)
+    })
+    setFormData({ ...formData, address: result.display_name })
+    setSearchResults([])
+  }
+
+  // 기본 포인트 추가
+  const addBasePoint = async () => {
+    if (!formData.name || !formData.address || !selectedLocation) {
+      alert('이름과 주소를 입력하고 검색 결과에서 선택해주세요.')
+      return
+    }
+
+    try {
+      const newPoint = await basePointsAPI.create({
+        name: formData.name,
+        address: formData.address,
+        type: formData.type,
+        coordinates: selectedLocation,
+        memo: formData.memo || undefined
+      })
+
+      setBasePoints([...basePoints, newPoint])
+
+      // 폼 초기화
+      setFormData({
+        name: '',
+        address: '',
+        type: 'accommodation',
+        memo: ''
+      })
+      setSelectedLocation(null)
+      setShowAddForm(false)
+    } catch (error) {
+      console.error('Failed to add base point:', error)
+      alert('기본 포인트 추가에 실패했습니다.')
+    }
+  }
+
+  // 기본 포인트 삭제
+  const deleteBasePoint = async (id: string) => {
+    if (confirm('이 위치를 삭제하시겠습니까?')) {
+      try {
+        await basePointsAPI.delete(id)
+        setBasePoints(basePoints.filter(p => p.id !== id))
+      } catch (error) {
+        console.error('Failed to delete base point:', error)
+        alert('기본 포인트 삭제에 실패했습니다.')
+      }
+    }
+  }
+
+  // 구마모토 중심 좌표
+  const kumamotoCenter: [number, number] = [32.8031, 130.7079]
+
+  // 타일 서버 URL
+  const tilesUrl = import.meta.env.VITE_MAP_TILES_URL || 'https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png'
+  const isCustomTiles = !!import.meta.env.VITE_MAP_TILES_URL
+
+  // 타입별 아이콘 색상
+  const getTypeEmoji = (type: BasePoint['type']) => {
+    switch (type) {
+      case 'accommodation': return '🏨'
+      case 'airport': return '✈️'
+      case 'station': return '🚉'
+      case 'parking': return '🅿️'
+      default: return '📍'
+    }
+  }
+
+  const getTypeName = (type: BasePoint['type']) => {
+    switch (type) {
+      case 'accommodation': return '숙소'
+      case 'airport': return '공항'
+      case 'station': return '역/정류장'
+      case 'parking': return '주차장'
+      default: return '기타'
+    }
+  }
+
+  // 마커 아이콘 설정
+  const attractionIcon = new Icon({
+    iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-2x-red.png',
+    shadowUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.7/images/marker-shadow.png',
+    iconSize: [25, 41],
+    iconAnchor: [12, 41],
+    popupAnchor: [1, -34],
+    shadowSize: [41, 41]
+  })
+
+  const basePointIcon = new Icon({
+    iconUrl: 'https://raw.githubusercontent.com/pointhi/leaflet-color-markers/master/img/marker-icon-2x-violet.png',
+    shadowUrl: 'https://cdnjs.cloudflare.com/ajax/libs/leaflet/0.7.7/images/marker-shadow.png',
+    iconSize: [25, 41],
+    iconAnchor: [12, 41],
+    popupAnchor: [1, -34],
+    shadowSize: [41, 41]
+  })
+
+  // 서버 사이드에서는 로딩 화면 표시
+  if (!isMounted) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-gray-100">
+          <div className="text-center">
+            <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-kumamoto-blue mx-auto mb-2"></div>
+            <p className="text-gray-500">지도를 불러오는 중...</p>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  // 에러 발생 시
+  if (mapError) {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-red-50">
+          <div className="text-center">
+            <p className="text-red-500 mb-2">⚠️ {mapError}</p>
+            <button
+              onClick={() => {
+                setMapError(null)
+                window.location.reload()
+              }}
+              className="px-4 py-2 bg-red-500 text-white rounded hover:bg-red-600"
+            >
+              새로고침
+            </button>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  // 클라이언트에서 렌더링
+  try {
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <div className="flex items-center justify-between mb-6">
+          <h2 className="text-2xl font-bold text-gray-800">🗺️ 구마모토 지도</h2>
+          <button
+            onClick={() => setShowAddForm(!showAddForm)}
+            className="px-4 py-2 bg-kumamoto-primary text-white rounded hover:bg-kumamoto-secondary transition-colors"
+          >
+            {showAddForm ? '닫기' : '+ 기본 정보 추가'}
+          </button>
+        </div>
+
+        {/* 기본 정보 추가 폼 */}
+        {showAddForm && (
+          <div className="mb-6 p-4 bg-gray-50 rounded-lg border border-gray-200">
+            <h3 className="font-semibold text-gray-800 mb-4">기본 정보 추가 (숙소, 공항, 이동 포인트)</h3>
+
+            <div className="space-y-3">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">이름</label>
+                <input
+                  type="text"
+                  value={formData.name}
+                  onChange={(e) => setFormData({ ...formData, name: e.target.value })}
+                  placeholder="예: 호텔 이름, 구마모토 공항 등"
+                  className="w-full px-3 py-2 border rounded"
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">분류</label>
+                <select
+                  value={formData.type}
+                  onChange={(e) => setFormData({ ...formData, type: e.target.value as BasePoint['type'] })}
+                  className="w-full px-3 py-2 border rounded"
+                >
+                  <option value="accommodation">🏨 숙소</option>
+                  <option value="airport">✈️ 공항</option>
+                  <option value="station">🚉 역/정류장</option>
+                  <option value="parking">🅿️ 주차장</option>
+                  <option value="other">📍 기타</option>
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">주소</label>
+                <input
+                  type="text"
+                  value={formData.address}
+                  onChange={(e) => setFormData({ ...formData, address: e.target.value })}
+                  placeholder="849-7 Hikimizu, Ozu, Kikuchi District, Kumamoto 869-1234"
+                  className="w-full px-3 py-2 border rounded"
+                />
+                <p className="text-xs text-gray-500 mt-1">
+                  주소를 직접 입력하세요 (영어, 한글, 일본어 모두 가능)
+                </p>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">위치 좌표 설정</label>
+
+                {/* 옵션 1: 간단한 검색으로 좌표 찾기 */}
+                <div className="mb-3 p-3 bg-blue-50 rounded border border-blue-200">
+                  <p className="text-xs font-medium text-gray-700 mb-2">옵션 1: 간단한 검색으로 좌표 찾기</p>
+                  <div className="flex gap-2">
+                    <input
+                      type="text"
+                      placeholder="간단한 키워드 입력 (예: 구마모토 공항, 오즈 등)"
+                      className="flex-1 px-3 py-2 border rounded text-sm"
+                      onKeyDown={(e) => {
+                        if (e.key === 'Enter') {
+                          searchAddress(e.currentTarget.value)
+                        }
+                      }}
+                    />
+                    <button
+                      onClick={(e) => {
+                        const input = e.currentTarget.previousElementSibling as HTMLInputElement
+                        searchAddress(input.value)
+                      }}
+                      disabled={isSearching}
+                      className="px-3 py-2 bg-kumamoto-blue text-white rounded hover:bg-opacity-90 disabled:bg-gray-400 text-sm"
+                    >
+                      {isSearching ? '검색중...' : '검색'}
+                    </button>
+                  </div>
+
+                  {/* 검색 결과 */}
+                  {searchResults.length > 0 && (
+                    <div className="mt-2 border rounded max-h-40 overflow-y-auto bg-white">
+                      {searchResults.map((result, idx) => (
+                        <button
+                          key={idx}
+                          onClick={() => selectSearchResult(result)}
+                          className="w-full text-left px-3 py-2 hover:bg-gray-100 border-b last:border-b-0 text-xs"
+                        >
+                          <div className="font-medium text-gray-800">결과 {idx + 1}</div>
+                          <div className="text-gray-600 truncate">{result.display_name}</div>
+                          <div className="text-gray-400 text-xs">
+                            위도: {parseFloat(result.lat).toFixed(4)}, 경도: {parseFloat(result.lon).toFixed(4)}
+                          </div>
+                        </button>
+                      ))}
+                    </div>
+                  )}
+                </div>
+
+                {/* 옵션 2: 좌표 직접 입력 */}
+                <div className="p-3 bg-green-50 rounded border border-green-200">
+                  <p className="text-xs font-medium text-gray-700 mb-2">옵션 2: 좌표 직접 입력 (Google Maps에서 확인)</p>
+                  <div className="grid grid-cols-2 gap-2">
+                    <div>
+                      <input
+                        type="number"
+                        step="0.0001"
+                        placeholder="위도 (예: 32.8031)"
+                        className="w-full px-3 py-2 border rounded text-sm"
+                        value={selectedLocation?.lat || ''}
+                        onChange={(e) => {
+                          const lat = parseFloat(e.target.value)
+                          if (!isNaN(lat)) {
+                            setSelectedLocation({
+                              lat,
+                              lng: selectedLocation?.lng || 0
+                            })
+                          }
+                        }}
+                      />
+                    </div>
+                    <div>
+                      <input
+                        type="number"
+                        step="0.0001"
+                        placeholder="경도 (예: 130.7079)"
+                        className="w-full px-3 py-2 border rounded text-sm"
+                        value={selectedLocation?.lng || ''}
+                        onChange={(e) => {
+                          const lng = parseFloat(e.target.value)
+                          if (!isNaN(lng)) {
+                            setSelectedLocation({
+                              lat: selectedLocation?.lat || 0,
+                              lng
+                            })
+                          }
+                        }}
+                      />
+                    </div>
+                  </div>
+                  <p className="text-xs text-gray-500 mt-1">
+                    💡 Google Maps에서 장소 우클릭 → 첫 번째 숫자 복사
+                  </p>
+                </div>
+
+                {selectedLocation && selectedLocation.lat !== 0 && selectedLocation.lng !== 0 && (
+                  <p className="mt-2 text-xs text-green-600 font-medium">
+                    ✓ 위치 선택됨 (위도: {selectedLocation.lat.toFixed(6)}, 경도: {selectedLocation.lng.toFixed(6)})
+                  </p>
+                )}
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">메모 (선택)</label>
+                <textarea
+                  value={formData.memo}
+                  onChange={(e) => setFormData({ ...formData, memo: e.target.value })}
+                  placeholder="추가 정보를 입력하세요"
+                  className="w-full px-3 py-2 border rounded"
+                  rows={2}
+                />
+              </div>
+
+              <button
+                onClick={addBasePoint}
+                className="w-full px-4 py-2 bg-kumamoto-green text-white rounded hover:bg-opacity-90"
+              >
+                추가하기
+              </button>
+            </div>
+          </div>
+        )}
+
+        {/* 저장된 기본 포인트 목록 */}
+        {basePoints.length > 0 && (
+          <div className="mb-4 p-3 bg-purple-50 border border-purple-200 rounded">
+            <h4 className="font-semibold text-gray-800 mb-2 text-sm">저장된 기본 정보</h4>
+            <div className="space-y-2">
+              {basePoints.map((point) => (
+                <div key={point.id} className="flex items-start justify-between bg-white p-2 rounded text-sm">
+                  <div className="flex-1">
+                    <div className="font-medium text-gray-800">
+                      {getTypeEmoji(point.type)} {point.name}
+                    </div>
+                    <div className="text-xs text-gray-500">{point.address}</div>
+                    {point.memo && <div className="text-xs text-gray-400 mt-1">{point.memo}</div>}
+                  </div>
+                  <button
+                    onClick={() => deleteBasePoint(point.id)}
+                    className="text-red-500 hover:text-red-700 text-xs ml-2"
+                  >
+                    삭제
+                  </button>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200">
+          <MapContainer
+            center={kumamotoCenter}
+            zoom={10}
+            style={{ height: '100%', width: '100%' }}
+            className="rounded-lg"
+          >
+            <TileLayer
+              url={tilesUrl}
+              attribution={
+                isCustomTiles
+                  ? '&copy; 구마모토 여행 지도 | OpenStreetMap contributors'
+                  : '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+              }
+              maxZoom={18}
+            />
+
+            {/* 기본 포인트 마커 (보라색) */}
+            {basePoints.map((point) => (
+              <Marker
+                key={point.id}
+                position={[point.coordinates.lat, point.coordinates.lng]}
+                icon={basePointIcon}
+              >
+                <Popup>
+                  <div className="p-2 max-w-xs">
+                    <h3 className="font-bold text-gray-800 mb-2 text-base">
+                      {getTypeEmoji(point.type)} {point.name}
+                    </h3>
+                    <p className="text-xs text-gray-500 mb-1">
+                      <span className="inline-block px-2 py-0.5 bg-purple-100 rounded">
+                        {getTypeName(point.type)}
+                      </span>
+                    </p>
+                    <p className="text-gray-600 text-sm mb-2">
+                      📍 {point.address}
+                    </p>
+                    {point.memo && (
+                      <p className="text-gray-500 text-xs">
+                        📝 {point.memo}
+                      </p>
+                    )}
+                  </div>
+                </Popup>
+              </Marker>
+            ))}
+
+            {/* 관광지 마커 (빨간색) */}
+            {attractions.map((attraction) => (
+              attraction.coordinates && (
+                <Marker
+                  key={attraction.id}
+                  position={[attraction.coordinates.lat, attraction.coordinates.lng]}
+                  icon={attractionIcon}
+                >
+                  <Popup>
+                    <div className="p-2 max-w-xs">
+                      <h3 className="font-bold text-gray-800 mb-2 text-base">
+                        {attraction.nameKo}
+                      </h3>
+                      <p className="text-gray-600 text-sm mb-2">
+                        {attraction.description}
+                      </p>
+                      <p className="text-gray-500 text-xs">
+                        📍 {attraction.location}
+                      </p>
+                    </div>
+                  </Popup>
+                </Marker>
+              )
+            ))}
+          </MapContainer>
+        </div>
+
+        <div className="mt-4 grid grid-cols-1 md:grid-cols-2 gap-2">
+          <div className="p-3 bg-purple-50 border border-purple-200 rounded text-sm text-purple-800">
+            <strong>🟣 보라색 마커:</strong> 기본 정보 (숙소, 공항, 이동 포인트)
+          </div>
+          <div className="p-3 bg-red-50 border border-red-200 rounded text-sm text-red-800">
+            <strong>🔴 빨간색 마커:</strong> 관광지
+          </div>
+        </div>
+      </div>
+    )
+  } catch (error) {
+    console.error('지도 렌더링 에러:', error)
+    return (
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-red-50">
+          <div className="text-center">
+            <p className="text-red-500 mb-2">⚠️ 지도를 렌더링할 수 없습니다.</p>
+            <button
+              onClick={() => window.location.reload()}
+              className="px-4 py-2 bg-red-500 text-white rounded hover:bg-red-600"
+            >
+              새로고침
+            </button>
+          </div>
+        </div>
+      </div>
+    )
+  }
+}
+
+export default TravelMap
diff --git a/src/components/TripSharingManager.tsx b/src/components/TripSharingManager.tsx
new file mode 100644
index 0000000..dd4b78f
--- /dev/null
+++ b/src/components/TripSharingManager.tsx
@@ -0,0 +1,436 @@
+import { useState, useEffect } from 'react'
+import { ShareLink, TravelPlan } from '../types'
+import { tripSharingService, SharePermissions, ShareLinkInfo } from '../services/tripSharing'
+
+interface TripSharingManagerProps {
+  trip: TravelPlan
+  onClose?: () => void
+}
+
+const TripSharingManager = ({ trip, onClose }: TripSharingManagerProps) => {
+  const [shareLinks, setShareLinks] = useState<ShareLink[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const [showCreateForm, setShowCreateForm] = useState(false)
+  const [isCreating, setIsCreating] = useState(false)
+  const [newShareLink, setNewShareLink] = useState<ShareLinkInfo | null>(null)
+
+  // 공유 링크 목록 로드
+  useEffect(() => {
+    loadShareLinks()
+  }, [trip.id])
+
+  const loadShareLinks = async () => {
+    try {
+      setIsLoading(true)
+      const links = await tripSharingService.getShareLinks(trip.id)
+      setShareLinks(links)
+    } catch (error) {
+      console.error('Failed to load share links:', error)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  // 공유 링크 생성
+  const handleCreateShareLink = async (formData: {
+    permission_type: keyof typeof SharePermissions
+    expires_in_days?: number
+    max_access_count?: number
+  }) => {
+    setIsCreating(true)
+    
+    try {
+      const permissions = SharePermissions[formData.permission_type].permissions
+      
+      const result = await tripSharingService.createShareLink({
+        trip_id: trip.id,
+        expires_in_days: formData.expires_in_days,
+        max_access_count: formData.max_access_count,
+        permissions
+      })
+
+      if (result.success && result.shareLink) {
+        setNewShareLink(result.shareLink)
+        setShowCreateForm(false)
+        await loadShareLinks()
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('공유 링크 생성 중 오류가 발생했습니다')
+    } finally {
+      setIsCreating(false)
+    }
+  }
+
+  // 공유 링크 비활성화
+  const handleDeactivateLink = async (linkId: string) => {
+    if (!confirm('이 공유 링크를 비활성화하시겠습니까?\n\n비활성화된 링크는 더 이상 사용할 수 없습니다.')) {
+      return
+    }
+
+    try {
+      const result = await tripSharingService.deactivateShareLink(linkId)
+      if (result.success) {
+        await loadShareLinks()
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('공유 링크 비활성화 중 오류가 발생했습니다')
+    }
+  }
+
+  // 클립보드에 복사
+  const copyToClipboard = async (text: string) => {
+    try {
+      await navigator.clipboard.writeText(text)
+      alert('클립보드에 복사되었습니다!')
+    } catch (error) {
+      // 클립보드 API가 지원되지 않는 경우 폴백
+      const textArea = document.createElement('textarea')
+      textArea.value = text
+      document.body.appendChild(textArea)
+      textArea.select()
+      document.execCommand('copy')
+      document.body.removeChild(textArea)
+      alert('클립보드에 복사되었습니다!')
+    }
+  }
+
+  const formatDate = (dateString: string) => {
+    return new Date(dateString).toLocaleDateString('ko-KR', {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric',
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  }
+
+  const getPermissionLabel = (permissions: ShareLink['permissions']) => {
+    if (permissions.can_edit) return SharePermissions.edit.label
+    if (permissions.can_comment) return SharePermissions.comment.label
+    return SharePermissions.view_only.label
+  }
+
+  const getPermissionColor = (permissions: ShareLink['permissions']) => {
+    if (permissions.can_edit) return 'bg-red-100 text-red-800'
+    if (permissions.can_comment) return 'bg-yellow-100 text-yellow-800'
+    return 'bg-green-100 text-green-800'
+  }
+
+  const isExpired = (link: ShareLink) => {
+    return link.expires_at && new Date(link.expires_at) < new Date()
+  }
+
+  const isAccessLimitReached = (link: ShareLink) => {
+    return link.max_access_count && link.access_count >= link.max_access_count
+  }
+
+  return (
+    <div className="bg-white rounded-lg shadow-xl max-w-4xl w-full max-h-[90vh] overflow-y-auto">
+      {/* 헤더 */}
+      <div className="p-6 border-b border-gray-200">
+        <div className="flex items-center justify-between">
+          <div>
+            <h2 className="text-2xl font-bold text-gray-800">🔗 여행 계획 공유</h2>
+            <p className="text-gray-600 mt-1">
+              "{trip.title}" 여행 계획을 다른 사람들과 공유하세요
+            </p>
+          </div>
+          {onClose && (
+            <button
+              onClick={onClose}
+              className="text-gray-400 hover:text-gray-600 text-2xl"
+            >
+              ×
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* 새로 생성된 공유 링크 표시 */}
+      {newShareLink && (
+        <div className="p-6 bg-blue-50 border-b border-blue-200">
+          <div className="flex items-start gap-3">
+            <div className="text-blue-600 text-2xl">🎉</div>
+            <div className="flex-1">
+              <h3 className="font-semibold text-blue-800 mb-2">공유 링크가 생성되었습니다!</h3>
+              <div className="bg-white p-3 rounded border border-blue-200">
+                <div className="flex items-center gap-2 mb-2">
+                  <code className="flex-1 text-sm bg-gray-100 px-2 py-1 rounded">
+                    {newShareLink.share_url}
+                  </code>
+                  <button
+                    onClick={() => copyToClipboard(newShareLink.share_url)}
+                    className="px-3 py-1 bg-blue-600 text-white rounded text-sm hover:bg-blue-700"
+                  >
+                    복사
+                  </button>
+                </div>
+                <div className="text-xs text-gray-600">
+                  권한: {getPermissionLabel(newShareLink.permissions)} | 
+                  접근 횟수: {newShareLink.access_count}
+                  {newShareLink.max_access_count && ` / ${newShareLink.max_access_count}`}
+                  {newShareLink.expires_at && ` | 만료: ${formatDate(newShareLink.expires_at)}`}
+                </div>
+              </div>
+            </div>
+            <button
+              onClick={() => setNewShareLink(null)}
+              className="text-blue-400 hover:text-blue-600"
+            >
+              ×
+            </button>
+          </div>
+        </div>
+      )}
+
+      {/* 공유 링크 생성 버튼 */}
+      <div className="p-6 border-b border-gray-200">
+        <button
+          onClick={() => setShowCreateForm(!showCreateForm)}
+          className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+        >
+          {showCreateForm ? '취소' : '➕ 새 공유 링크 만들기'}
+        </button>
+      </div>
+
+      {/* 공유 링크 생성 폼 */}
+      {showCreateForm && (
+        <CreateShareLinkForm
+          onSubmit={handleCreateShareLink}
+          isCreating={isCreating}
+          onCancel={() => setShowCreateForm(false)}
+        />
+      )}
+
+      {/* 기존 공유 링크 목록 */}
+      <div className="p-6">
+        <h3 className="text-lg font-semibold text-gray-800 mb-4">
+          기존 공유 링크 ({shareLinks.length}개)
+        </h3>
+
+        {isLoading ? (
+          <div className="text-center py-8">
+            <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mx-auto mb-2"></div>
+            <p className="text-gray-500">공유 링크를 불러오는 중...</p>
+          </div>
+        ) : shareLinks.length === 0 ? (
+          <div className="text-center py-8">
+            <div className="text-4xl mb-3">🔗</div>
+            <div className="text-gray-600">아직 생성된 공유 링크가 없습니다</div>
+            <div className="text-sm text-gray-500 mt-1">
+              위의 버튼을 클릭해서 첫 번째 공유 링크를 만들어보세요
+            </div>
+          </div>
+        ) : (
+          <div className="space-y-4">
+            {shareLinks.map((link) => {
+              const expired = isExpired(link)
+              const accessLimited = isAccessLimitReached(link)
+              const inactive = !link.is_active || expired || accessLimited
+              
+              return (
+                <div
+                  key={link.id}
+                  className={`border rounded-lg p-4 ${
+                    inactive ? 'bg-gray-50 border-gray-300' : 'bg-white border-gray-200'
+                  }`}
+                >
+                  <div className="flex items-start justify-between">
+                    <div className="flex-1">
+                      <div className="flex items-center gap-2 mb-2">
+                        <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${getPermissionColor(link.permissions)}`}>
+                          {getPermissionLabel(link.permissions)}
+                        </span>
+                        {inactive && (
+                          <span className="inline-flex items-center px-2 py-1 rounded-full text-xs font-medium bg-gray-100 text-gray-800">
+                            {!link.is_active ? '비활성화됨' : expired ? '만료됨' : '접근 한도 초과'}
+                          </span>
+                        )}
+                      </div>
+
+                      <div className="flex items-center gap-2 mb-2">
+                        <code className={`flex-1 text-sm px-2 py-1 rounded ${
+                          inactive ? 'bg-gray-200 text-gray-500' : 'bg-gray-100 text-gray-800'
+                        }`}>
+                          {tripSharingService.generateShareUrl(link.share_code)}
+                        </code>
+                        {!inactive && (
+                          <button
+                            onClick={() => copyToClipboard(tripSharingService.generateShareUrl(link.share_code))}
+                            className="px-3 py-1 bg-gray-600 text-white rounded text-sm hover:bg-gray-700"
+                          >
+                            복사
+                          </button>
+                        )}
+                      </div>
+
+                      <div className="text-xs text-gray-500 space-y-1">
+                        <div>생성일: {formatDate(link.created_at)}</div>
+                        <div>
+                          접근 횟수: {link.access_count}
+                          {link.max_access_count && ` / ${link.max_access_count}`}
+                        </div>
+                        {link.expires_at && (
+                          <div>만료일: {formatDate(link.expires_at)}</div>
+                        )}
+                        {link.last_accessed && (
+                          <div>마지막 접근: {formatDate(link.last_accessed)}</div>
+                        )}
+                      </div>
+                    </div>
+
+                    {link.is_active && !expired && !accessLimited && (
+                      <button
+                        onClick={() => handleDeactivateLink(link.id)}
+                        className="px-3 py-1 bg-red-100 text-red-700 rounded text-sm hover:bg-red-200"
+                      >
+                        비활성화
+                      </button>
+                    )}
+                  </div>
+                </div>
+              )
+            })}
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+// 공유 링크 생성 폼
+const CreateShareLinkForm = ({
+  onSubmit,
+  isCreating,
+  onCancel
+}: {
+  onSubmit: (data: any) => void
+  isCreating: boolean
+  onCancel: () => void
+}) => {
+  const [formData, setFormData] = useState({
+    permission_type: 'view_only' as keyof typeof SharePermissions,
+    expires_in_days: 7,
+    max_access_count: undefined as number | undefined,
+    has_expiry: true,
+    has_access_limit: false
+  })
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault()
+    onSubmit({
+      permission_type: formData.permission_type,
+      expires_in_days: formData.has_expiry ? formData.expires_in_days : undefined,
+      max_access_count: formData.has_access_limit ? formData.max_access_count : undefined
+    })
+  }
+
+  return (
+    <div className="p-6 bg-gray-50 border-b border-gray-200">
+      <form onSubmit={handleSubmit} className="space-y-4">
+        <div>
+          <label className="block text-sm font-medium text-gray-700 mb-2">
+            공유 권한
+          </label>
+          <div className="space-y-2">
+            {Object.entries(SharePermissions).map(([key, permission]) => (
+              <label key={key} className="flex items-start gap-3 p-3 border border-gray-200 rounded cursor-pointer hover:bg-white">
+                <input
+                  type="radio"
+                  name="permission_type"
+                  value={key}
+                  checked={formData.permission_type === key}
+                  onChange={(e) => setFormData({ ...formData, permission_type: e.target.value as any })}
+                  className="mt-1"
+                />
+                <div>
+                  <div className="font-medium text-gray-800">{permission.label}</div>
+                  <div className="text-sm text-gray-600">{permission.description}</div>
+                </div>
+              </label>
+            ))}
+          </div>
+        </div>
+
+        <div>
+          <label className="flex items-center gap-2 mb-2">
+            <input
+              type="checkbox"
+              checked={formData.has_expiry}
+              onChange={(e) => setFormData({ ...formData, has_expiry: e.target.checked })}
+            />
+            <span className="text-sm font-medium text-gray-700">만료 기간 설정</span>
+          </label>
+          {formData.has_expiry && (
+            <select
+              value={formData.expires_in_days}
+              onChange={(e) => setFormData({ ...formData, expires_in_days: parseInt(e.target.value) })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            >
+              <option value={1}>1일</option>
+              <option value={3}>3일</option>
+              <option value={7}>7일</option>
+              <option value={14}>14일</option>
+              <option value={30}>30일</option>
+              <option value={90}>90일</option>
+            </select>
+          )}
+        </div>
+
+        <div>
+          <label className="flex items-center gap-2 mb-2">
+            <input
+              type="checkbox"
+              checked={formData.has_access_limit}
+              onChange={(e) => setFormData({ ...formData, has_access_limit: e.target.checked })}
+            />
+            <span className="text-sm font-medium text-gray-700">접근 횟수 제한</span>
+          </label>
+          {formData.has_access_limit && (
+            <input
+              type="number"
+              min="1"
+              max="1000"
+              value={formData.max_access_count || ''}
+              onChange={(e) => setFormData({ ...formData, max_access_count: parseInt(e.target.value) || undefined })}
+              placeholder="최대 접근 횟수"
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            />
+          )}
+        </div>
+
+        <div className="flex gap-3 pt-4">
+          <button
+            type="button"
+            onClick={onCancel}
+            className="flex-1 px-4 py-2 border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+          >
+            취소
+          </button>
+          <button
+            type="submit"
+            disabled={isCreating}
+            className="flex-1 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50"
+          >
+            {isCreating ? (
+              <div className="flex items-center justify-center gap-2">
+                <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white"></div>
+                생성 중...
+              </div>
+            ) : (
+              '공유 링크 생성'
+            )}
+          </button>
+        </div>
+      </form>
+    </div>
+  )
+}
+
+export default TripSharingManager
diff --git a/src/components/UnifiedMap.tsx b/src/components/UnifiedMap.tsx
new file mode 100644
index 0000000..cb55ee4
--- /dev/null
+++ b/src/components/UnifiedMap.tsx
@@ -0,0 +1,303 @@
+import { useEffect, useState } from 'react'
+import { Attraction, BasePoint } from '../types'
+import { basePointsAPI } from '../services/api'
+import GoogleMapComponent from './GoogleMapComponent'
+import LeafletMapComponent from './LeafletMapComponent'
+import PlacesSearch from './PlacesSearch'
+import GoogleAuthManager from './GoogleAuthManager'
+import { PlaceResult, googlePlacesService } from '../services/googlePlaces'
+import { SavedPlace, GoogleMyMap } from '../services/googleAuth'
+import { offlineSupportService, OfflineUtils } from '../services/offlineSupport'
+import { canUseGoogleMaps } from '../services/googleMapsUsage'
+
+interface UnifiedMapProps {
+  attractions: Attraction[]
+  basePoints?: BasePoint[]
+  onAddBasePoint?: (basePoint: BasePoint) => void
+  onDeleteBasePoint?: (id: string) => void
+  selectedActivityId?: string
+  currentDaySchedule?: any
+  onActivityClick?: (activity: any) => void
+  getActivityCoords?: (activity: any) => [number, number] | null
+  showControls?: boolean
+  showPlacesSearch?: boolean
+  onAddPlaceToItinerary?: (place: PlaceResult) => void
+  className?: string
+}
+
+type MapProvider = 'google' | 'leaflet'
+
+const UnifiedMap = ({ 
+  attractions, 
+  basePoints: propBasePoints,
+  onAddBasePoint,
+  onDeleteBasePoint,
+  selectedActivityId,
+  currentDaySchedule,
+  onActivityClick,
+  getActivityCoords,
+  showControls = true,
+  showPlacesSearch = true,
+  onAddPlaceToItinerary,
+  className = ''
+}: UnifiedMapProps) => {
+  const [mapProvider, setMapProvider] = useState<MapProvider>('leaflet')
+  const [basePoints, setBasePoints] = useState<BasePoint[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const [showSearchPanel, setShowSearchPanel] = useState(false)
+  const [showGoogleAuth, setShowGoogleAuth] = useState(false)
+  const [mapInstance, setMapInstance] = useState<google.maps.Map | null>(null)
+  const [isOfflineMode, setIsOfflineMode] = useState(false)
+  const [offlineMessage, setOfflineMessage] = useState('')
+
+  useEffect(() => {
+    if (propBasePoints) {
+      setBasePoints(propBasePoints)
+      setIsLoading(false)
+    } else {
+      loadBasePoints()
+    }
+
+    // 오프라인 모드 확인
+    checkOfflineMode()
+  }, [propBasePoints])
+
+  // 지도 제공자 변경 시 오프라인 모드 재확인
+  useEffect(() => {
+    checkOfflineMode()
+  }, [mapProvider])
+
+  const loadBasePoints = async () => {
+    try {
+      const points = await basePointsAPI.getAll()
+      setBasePoints(points)
+    } catch (error) {
+      console.error('Failed to load base points:', error)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleBasePointsUpdate = (newBasePoints: BasePoint[]) => {
+    setBasePoints(newBasePoints)
+  }
+
+  // Google Maps 인스턴스 초기화 시 Places Service 설정
+  const handleMapInit = (map: google.maps.Map) => {
+    setMapInstance(map)
+    if (mapProvider === 'google') {
+      googlePlacesService.initialize(map)
+    }
+  }
+
+  // 장소 선택 핸들러
+  const handlePlaceSelect = (place: PlaceResult) => {
+    // 지도에서 해당 위치로 이동
+    if (mapInstance) {
+      mapInstance.setCenter({ lat: place.geometry.location.lat, lng: place.geometry.location.lng })
+      mapInstance.setZoom(16)
+    }
+  }
+
+  // 일정에 장소 추가
+  const handleAddPlaceToItinerary = (place: PlaceResult) => {
+    if (onAddPlaceToItinerary) {
+      onAddPlaceToItinerary(place)
+    }
+  }
+
+  // 오프라인 모드 확인
+  const checkOfflineMode = () => {
+    if (mapProvider === 'google') {
+      const shouldUseOffline = OfflineUtils.shouldUseOfflineMode()
+      setIsOfflineMode(shouldUseOffline)
+      
+      if (shouldUseOffline) {
+        setOfflineMessage(OfflineUtils.getOfflineModeMessage())
+      } else {
+        setOfflineMessage('')
+      }
+    } else {
+      setIsOfflineMode(false)
+      setOfflineMessage('')
+    }
+  }
+
+  // Google 저장된 장소 로드 핸들러
+  const handleSavedPlacesLoad = (places: SavedPlace[]) => {
+    console.log('Google 저장된 장소 로드됨:', places.length, '개')
+    // 필요시 부모 컴포넌트로 전달
+  }
+
+  // Google My Maps 로드 핸들러
+  const handleMyMapsLoad = (maps: GoogleMyMap[]) => {
+    console.log('Google My Maps 로드됨:', maps.length, '개')
+    // 필요시 부모 컴포넌트로 전달
+  }
+
+  if (isLoading) {
+    return (
+      <div className={`bg-white rounded-lg shadow-md p-6 ${className}`}>
+        {showControls && <h2 className="text-2xl font-bold text-gray-800 mb-6">🗺️ 구마모토 지도</h2>}
+        <div className="w-full h-96 rounded-lg overflow-hidden border border-gray-200 flex items-center justify-center bg-gray-100">
+          <div className="text-center">
+            <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-kumamoto-blue mx-auto mb-2"></div>
+            <p className="text-gray-500">지도를 불러오는 중...</p>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className={showControls ? `bg-white rounded-lg shadow-md p-6 ${className}` : className}>
+      {showControls && (
+        <>
+          <div className="flex items-center justify-between mb-6">
+            <h2 className="text-2xl font-bold text-gray-800">🗺️ 구마모토 지도</h2>
+            
+            <div className="flex items-center gap-2 flex-wrap">
+              {/* Google 로그인 토글 */}
+              {mapProvider === 'google' && (
+                <button
+                  onClick={() => setShowGoogleAuth(!showGoogleAuth)}
+                  className={`px-3 py-1 text-sm rounded transition-colors ${
+                    showGoogleAuth
+                      ? 'bg-blue-600 text-white'
+                      : 'bg-blue-100 text-blue-700 hover:bg-blue-200'
+                  }`}
+                >
+                  🔐 Google 연동
+                </button>
+              )}
+
+              {/* Places 검색 토글 */}
+              {showPlacesSearch && mapProvider === 'google' && !isOfflineMode && (
+                <button
+                  onClick={() => setShowSearchPanel(!showSearchPanel)}
+                  className={`px-3 py-1 text-sm rounded transition-colors ${
+                    showSearchPanel
+                      ? 'bg-kumamoto-primary text-white'
+                      : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+                  }`}
+                >
+                  🔍 장소 검색
+                </button>
+              )}
+              
+              {/* 지도 제공자 선택 */}
+              <div className="flex items-center gap-2">
+                <span className="text-sm font-medium text-gray-700">지도:</span>
+                <div className="flex bg-gray-100 rounded-lg p-1">
+                  <button
+                    onClick={() => setMapProvider('leaflet')}
+                    className={`px-3 py-1 text-sm rounded transition-colors ${
+                      mapProvider === 'leaflet'
+                        ? 'bg-white text-kumamoto-primary shadow-sm font-medium'
+                        : 'text-gray-600 hover:text-gray-800'
+                    }`}
+                  >
+                    🌍 OSM
+                  </button>
+                  <button
+                    onClick={() => setMapProvider('google')}
+                    className={`px-3 py-1 text-sm rounded transition-colors ${
+                      mapProvider === 'google'
+                        ? 'bg-white text-kumamoto-primary shadow-sm font-medium'
+                        : 'text-gray-600 hover:text-gray-800'
+                    }`}
+                  >
+                    🗺️ Google {isOfflineMode && '(오프라인)'}
+                  </button>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          {/* 오프라인 모드 알림 */}
+          {isOfflineMode && offlineMessage && (
+            <div className="mb-4 p-3 bg-orange-50 border border-orange-200 rounded-lg">
+              <div className="flex items-center gap-2 text-orange-700">
+                <span>📱</span>
+                <span className="text-sm">{offlineMessage}</span>
+              </div>
+              <div className="text-xs text-orange-600 mt-1">
+                캐시된 데이터로 지도를 표시합니다. 일부 기능이 제한될 수 있습니다.
+              </div>
+            </div>
+          )}
+
+          {/* Google 로그인 패널 */}
+          {showGoogleAuth && mapProvider === 'google' && (
+            <div className="mb-6">
+              <GoogleAuthManager
+                onSavedPlacesLoad={handleSavedPlacesLoad}
+                onMyMapsLoad={handleMyMapsLoad}
+              />
+            </div>
+          )}
+
+          {/* Places 검색 패널 */}
+          {showSearchPanel && showPlacesSearch && mapProvider === 'google' && !isOfflineMode && (
+            <div className="mb-6">
+              <PlacesSearch
+                onPlaceSelect={handlePlaceSelect}
+                onAddToItinerary={onAddPlaceToItinerary ? handleAddPlaceToItinerary : undefined}
+                currentLocation={{ lat: 32.7898, lng: 130.7417 }}
+              />
+            </div>
+          )}
+
+          {/* 지도 제공자별 설명 */}
+          <div className="mb-4 p-3 bg-gray-50 rounded-lg border border-gray-200">
+            {mapProvider === 'leaflet' ? (
+              <div className="text-sm text-gray-700">
+                <strong>🌍 오픈소스 맵 (OpenStreetMap)</strong>
+                <div className="text-xs text-gray-600 mt-1">
+                  • 무료 사용 • API 키 불필요 • 커뮤니티 기반 지도 데이터 • 항상 사용 가능
+                </div>
+              </div>
+            ) : (
+              <div className="text-sm text-gray-700">
+                <strong>🗺️ 구글 맵 {isOfflineMode ? '(오프라인 모드)' : ''}</strong>
+                <div className="text-xs text-gray-600 mt-1">
+                  {isOfflineMode ? (
+                    <>• 캐시된 데이터 사용 • 제한된 기능 • 오프라인 지원</>
+                  ) : (
+                    <>• 정확한 지도 데이터 • Google 계정 연동 • 실시간 장소 검색 • 길찾기 기능</>
+                  )}
+                </div>
+              </div>
+            )}
+          </div>
+        </>
+      )}
+
+      {/* 지도 컴포넌트 렌더링 */}
+      {mapProvider === 'google' ? (
+        <GoogleMapComponent 
+          attractions={attractions} 
+          basePoints={basePoints}
+          onBasePointsUpdate={onAddBasePoint ? handleBasePointsUpdate : undefined}
+          selectedActivityId={selectedActivityId}
+          currentDaySchedule={currentDaySchedule}
+          onActivityClick={onActivityClick}
+          getActivityCoords={getActivityCoords}
+          onMapInit={handleMapInit}
+        />
+      ) : (
+        <LeafletMapComponent 
+          attractions={attractions} 
+          basePoints={basePoints}
+          onBasePointsUpdate={onAddBasePoint ? handleBasePointsUpdate : undefined}
+          selectedActivityId={selectedActivityId}
+          currentDaySchedule={currentDaySchedule}
+          onActivityClick={onActivityClick}
+          getActivityCoords={getActivityCoords}
+        />
+      )}
+    </div>
+  )
+}
+
+export default UnifiedMap
diff --git a/src/components/UserDashboard.tsx b/src/components/UserDashboard.tsx
new file mode 100644
index 0000000..5426bd9
--- /dev/null
+++ b/src/components/UserDashboard.tsx
@@ -0,0 +1,660 @@
+import { useState, useEffect } from 'react'
+import { Link } from 'react-router-dom'
+import { tripManagerService, TripCategories, TripStatus, TripCreateData } from '../services/tripManager'
+import { TravelPlan } from '../types'
+import { userAuthService } from '../services/userAuth'
+import TemplateBrowser from './TemplateBrowser'
+import TripSharingManager from './TripSharingManager'
+
+interface UserDashboardProps {
+  className?: string
+}
+
+const UserDashboard = ({ className = '' }: UserDashboardProps) => {
+  const [trips, setTrips] = useState<TravelPlan[]>([])
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [showCreateForm, setShowCreateForm] = useState(false)
+  const [showTemplates, setShowTemplates] = useState(false)
+  const [sharingTrip, setSharingTrip] = useState<TravelPlan | null>(null)
+  const [filter, setFilter] = useState({
+    status: 'all' as 'all' | TravelPlan['status'],
+    category: 'all' as 'all' | TravelPlan['template_category'],
+    search: ''
+  })
+
+  const currentUser = userAuthService.getCurrentUser()
+
+  useEffect(() => {
+    loadTrips()
+  }, [filter])
+
+  const loadTrips = async () => {
+    try {
+      setIsLoading(true)
+      const filterParams = {
+        ...(filter.status !== 'all' && { status: filter.status }),
+        ...(filter.category !== 'all' && { template_category: filter.category }),
+        ...(filter.search && { search: filter.search })
+      }
+
+      const result = await tripManagerService.getUserTrips(filterParams)
+      setTrips(result.trips)
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '여행 목록을 불러올 수 없습니다')
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleDeleteTrip = async (tripId: string, tripTitle: string) => {
+    if (!confirm(`"${tripTitle}" 여행 계획을 정말 삭제하시겠습니까?\n\n⚠️ 삭제된 계획은 복구할 수 없습니다.`)) {
+      return
+    }
+
+    try {
+      const result = await tripManagerService.deleteTrip(tripId)
+      if (result.success) {
+        await loadTrips()
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('여행 계획 삭제 중 오류가 발생했습니다')
+    }
+  }
+
+  const handleDuplicateTrip = async (tripId: string, tripTitle: string) => {
+    const newTitle = prompt(`복사할 여행 계획의 제목을 입력하세요:`, `${tripTitle} (복사본)`)
+    if (!newTitle) return
+
+    try {
+      const result = await tripManagerService.duplicateTrip(tripId, newTitle)
+      if (result.success) {
+        await loadTrips()
+        alert(result.message)
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('여행 계획 복사 중 오류가 발생했습니다')
+    }
+  }
+
+  const formatDate = (date: Date | string) => {
+    const d = new Date(date)
+    return d.toLocaleDateString('ko-KR', {
+      year: 'numeric',
+      month: 'short',
+      day: 'numeric'
+    })
+  }
+
+  const getDuration = (startDate: Date | string, endDate: Date | string) => {
+    const start = new Date(startDate)
+    const end = new Date(endDate)
+    const diffTime = Math.abs(end.getTime() - start.getTime())
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))
+    return `${diffDays}일`
+  }
+
+  const getStatusInfo = (status: TravelPlan['status']) => {
+    return TripStatus[status] || TripStatus.draft
+  }
+
+  const getCategoryInfo = (category?: TravelPlan['template_category']) => {
+    return category ? TripCategories[category] : TripCategories.other
+  }
+
+  if (isLoading) {
+    return (
+      <div className={`bg-white rounded-lg shadow-md p-6 ${className}`}>
+        <div className="flex items-center justify-center py-12">
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mr-3"></div>
+          <span>여행 목록을 불러오는 중...</span>
+        </div>
+      </div>
+    )
+  }
+
+  if (error) {
+    return (
+      <div className={`bg-white rounded-lg shadow-md p-6 ${className}`}>
+        <div className="text-center py-12">
+          <div className="text-red-500 text-4xl mb-4">⚠️</div>
+          <div className="text-red-700">{error}</div>
+          <button
+            onClick={loadTrips}
+            className="mt-4 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+          >
+            다시 시도
+          </button>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className={`space-y-6 ${className}`}>
+      {/* 헤더 */}
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <div className="flex items-center justify-between mb-6">
+          <div>
+            <h1 className="text-2xl font-bold text-gray-800">
+              🗺️ 내 여행 계획
+            </h1>
+            <p className="text-gray-600 mt-1">
+              {currentUser?.name}님의 여행 계획을 관리하세요
+            </p>
+          </div>
+          <div className="flex gap-3">
+            <button
+              onClick={() => setShowTemplates(true)}
+              className="px-6 py-3 bg-purple-600 text-white rounded-lg hover:bg-purple-700 transition-colors"
+            >
+              🌟 템플릿으로 만들기
+            </button>
+            <button
+              onClick={() => setShowCreateForm(true)}
+              className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700 transition-colors"
+            >
+              ➕ 직접 만들기
+            </button>
+          </div>
+        </div>
+
+        {/* 통계 카드 */}
+        <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+          <div className="bg-blue-50 p-4 rounded-lg border border-blue-200">
+            <div className="text-2xl font-bold text-blue-800">
+              {trips.filter(t => t.status === 'active').length}
+            </div>
+            <div className="text-sm text-blue-600">진행 중</div>
+          </div>
+          <div className="bg-green-50 p-4 rounded-lg border border-green-200">
+            <div className="text-2xl font-bold text-green-800">
+              {trips.filter(t => t.status === 'completed').length}
+            </div>
+            <div className="text-sm text-green-600">완료</div>
+          </div>
+          <div className="bg-gray-50 p-4 rounded-lg border border-gray-200">
+            <div className="text-2xl font-bold text-gray-800">
+              {trips.filter(t => t.status === 'draft').length}
+            </div>
+            <div className="text-sm text-gray-600">계획 중</div>
+          </div>
+          <div className="bg-purple-50 p-4 rounded-lg border border-purple-200">
+            <div className="text-2xl font-bold text-purple-800">
+              {trips.length}
+            </div>
+            <div className="text-sm text-purple-600">전체</div>
+          </div>
+        </div>
+      </div>
+
+      {/* 필터 */}
+      <div className="bg-white rounded-lg shadow-md p-6">
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              상태
+            </label>
+            <select
+              value={filter.status}
+              onChange={(e) => setFilter({ ...filter, status: e.target.value as any })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            >
+              <option value="all">전체</option>
+              <option value="draft">계획 중</option>
+              <option value="active">진행 중</option>
+              <option value="completed">완료</option>
+              <option value="cancelled">취소</option>
+            </select>
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              지역
+            </label>
+            <select
+              value={filter.category}
+              onChange={(e) => setFilter({ ...filter, category: e.target.value as any })}
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            >
+              <option value="all">전체</option>
+              {Object.entries(TripCategories).map(([key, category]) => (
+                <option key={key} value={key}>
+                  {category.label}
+                </option>
+              ))}
+            </select>
+          </div>
+
+          <div>
+            <label className="block text-sm font-medium text-gray-700 mb-1">
+              검색
+            </label>
+            <input
+              type="text"
+              value={filter.search}
+              onChange={(e) => setFilter({ ...filter, search: e.target.value })}
+              placeholder="제목, 설명, 도시명으로 검색..."
+              className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* 여행 목록 */}
+      <div className="bg-white rounded-lg shadow-md">
+        {trips.length === 0 ? (
+          <div className="text-center py-12">
+            <div className="text-4xl mb-4">✈️</div>
+            <div className="text-lg font-medium text-gray-800 mb-2">
+              아직 여행 계획이 없습니다
+            </div>
+            <div className="text-gray-600 mb-4">
+              첫 번째 여행 계획을 만들어보세요!
+            </div>
+            <div className="flex gap-3">
+              <button
+                onClick={() => setShowTemplates(true)}
+                className="px-6 py-3 bg-purple-600 text-white rounded-lg hover:bg-purple-700"
+              >
+                🌟 템플릿으로 만들기
+              </button>
+              <button
+                onClick={() => setShowCreateForm(true)}
+                className="px-6 py-3 bg-blue-600 text-white rounded-lg hover:bg-blue-700"
+              >
+                ➕ 직접 만들기
+              </button>
+            </div>
+          </div>
+        ) : (
+          <div className="divide-y divide-gray-200">
+            {trips.map((trip) => {
+              const statusInfo = getStatusInfo(trip.status)
+              const categoryInfo = getCategoryInfo(trip.template_category)
+              
+              return (
+                <div key={trip.id} className="p-6 hover:bg-gray-50 transition-colors">
+                  <div className="flex items-start justify-between">
+                    <div className="flex-1">
+                      <div className="flex items-center gap-3 mb-2">
+                        <h3 className="text-lg font-semibold text-gray-800">
+                          {trip.title}
+                        </h3>
+                        <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${statusInfo.color}`}>
+                          {statusInfo.label}
+                        </span>
+                        <span className={`inline-flex items-center px-2 py-1 rounded-full text-xs font-medium ${categoryInfo.color}`}>
+                          {categoryInfo.label}
+                        </span>
+                      </div>
+
+                      <div className="text-gray-600 mb-2">
+                        📍 {trip.destination.city}, {trip.destination.country}
+                        {trip.destination.region && ` (${trip.destination.region})`}
+                      </div>
+
+                      {trip.description && (
+                        <div className="text-gray-600 mb-2 text-sm">
+                          {trip.description}
+                        </div>
+                      )}
+
+                      <div className="flex items-center gap-4 text-sm text-gray-500">
+                        <span>📅 {formatDate(trip.startDate)} - {formatDate(trip.endDate)}</span>
+                        <span>⏱️ {getDuration(trip.startDate, trip.endDate)}</span>
+                        <span>📝 {trip.schedule.length}일 일정</span>
+                        {trip.tags.length > 0 && (
+                          <span>🏷️ {trip.tags.join(', ')}</span>
+                        )}
+                      </div>
+                    </div>
+
+                    <div className="flex items-center gap-2 ml-4">
+                      <Link
+                        to={`/plan/${trip.id}`}
+                        className="px-3 py-1 text-sm bg-blue-100 text-blue-700 rounded hover:bg-blue-200"
+                      >
+                        ✏️ 편집
+                      </Link>
+                      <Link
+                        to={`/trip/${trip.id}`}
+                        className="px-3 py-1 text-sm bg-green-100 text-green-700 rounded hover:bg-green-200"
+                      >
+                        🗺️ 보기
+                      </Link>
+                      <button
+                        onClick={() => setSharingTrip(trip)}
+                        className="px-3 py-1 text-sm bg-purple-100 text-purple-700 rounded hover:bg-purple-200"
+                      >
+                        🔗 공유
+                      </button>
+                      <button
+                        onClick={() => handleDuplicateTrip(trip.id, trip.title)}
+                        className="px-3 py-1 text-sm bg-gray-100 text-gray-700 rounded hover:bg-gray-200"
+                      >
+                        📋 복사
+                      </button>
+                      <button
+                        onClick={() => handleDeleteTrip(trip.id, trip.title)}
+                        className="px-3 py-1 text-sm bg-red-100 text-red-700 rounded hover:bg-red-200"
+                      >
+                        🗑️ 삭제
+                      </button>
+                    </div>
+                  </div>
+                </div>
+              )
+            })}
+          </div>
+        )}
+      </div>
+
+      {/* 템플릿 브라우저 */}
+      {showTemplates && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
+          <TemplateBrowser
+            onClose={() => setShowTemplates(false)}
+            onTemplateSelect={() => {
+              setShowTemplates(false)
+              loadTrips()
+            }}
+            className="w-full max-w-6xl max-h-[90vh] overflow-y-auto"
+          />
+        </div>
+      )}
+
+      {/* 공유 관리 모달 */}
+      {sharingTrip && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
+          <TripSharingManager
+            trip={sharingTrip}
+            onClose={() => setSharingTrip(null)}
+          />
+        </div>
+      )}
+
+      {/* 새 여행 만들기 모달 */}
+      {showCreateForm && (
+        <CreateTripModal
+          onClose={() => setShowCreateForm(false)}
+          onSuccess={() => {
+            setShowCreateForm(false)
+            loadTrips()
+          }}
+        />
+      )}
+    </div>
+  )
+}
+
+// 새 여행 만들기 모달
+const CreateTripModal = ({ onClose, onSuccess }: { onClose: () => void; onSuccess: () => void }) => {
+  const [formData, setFormData] = useState<TripCreateData>({
+    title: '',
+    description: '',
+    destination: {
+      country: '',
+      city: '',
+      region: ''
+    },
+    startDate: new Date(),
+    endDate: new Date(),
+    template_category: 'other',
+    tags: [],
+    is_public: false
+  })
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [tagInput, setTagInput] = useState('')
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault()
+    setIsSubmitting(true)
+
+    try {
+      const result = await tripManagerService.createTrip(formData)
+      if (result.success) {
+        alert(result.message)
+        onSuccess()
+      } else {
+        alert(result.message)
+      }
+    } catch (error) {
+      alert('여행 계획 생성 중 오류가 발생했습니다')
+    } finally {
+      setIsSubmitting(false)
+    }
+  }
+
+  const addTag = () => {
+    if (tagInput.trim() && !formData.tags?.includes(tagInput.trim())) {
+      setFormData({
+        ...formData,
+        tags: [...(formData.tags || []), tagInput.trim()]
+      })
+      setTagInput('')
+    }
+  }
+
+  const removeTag = (tagToRemove: string) => {
+    setFormData({
+      ...formData,
+      tags: formData.tags?.filter(tag => tag !== tagToRemove) || []
+    })
+  }
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50 p-4">
+      <div className="bg-white rounded-lg w-full max-w-2xl max-h-[90vh] overflow-y-auto">
+        <div className="p-6">
+          <h3 className="text-xl font-semibold mb-6">✈️ 새 여행 계획 만들기</h3>
+          
+          <form onSubmit={handleSubmit} className="space-y-4">
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              <div className="md:col-span-2">
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  여행 제목 *
+                </label>
+                <input
+                  type="text"
+                  value={formData.title}
+                  onChange={(e) => setFormData({ ...formData, title: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="예: 도쿄 3박 4일 여행"
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  국가 *
+                </label>
+                <input
+                  type="text"
+                  value={formData.destination.country}
+                  onChange={(e) => setFormData({ 
+                    ...formData, 
+                    destination: { ...formData.destination, country: e.target.value }
+                  })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="예: 일본"
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  도시 *
+                </label>
+                <input
+                  type="text"
+                  value={formData.destination.city}
+                  onChange={(e) => setFormData({ 
+                    ...formData, 
+                    destination: { ...formData.destination, city: e.target.value }
+                  })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="예: 도쿄"
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  출발일 *
+                </label>
+                <input
+                  type="date"
+                  value={formData.startDate.toISOString().split('T')[0]}
+                  onChange={(e) => setFormData({ ...formData, startDate: new Date(e.target.value) })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  도착일 *
+                </label>
+                <input
+                  type="date"
+                  value={formData.endDate.toISOString().split('T')[0]}
+                  onChange={(e) => setFormData({ ...formData, endDate: new Date(e.target.value) })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  min={formData.startDate.toISOString().split('T')[0]}
+                  required
+                />
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  지역 카테고리
+                </label>
+                <select
+                  value={formData.template_category}
+                  onChange={(e) => setFormData({ ...formData, template_category: e.target.value as any })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                >
+                  {Object.entries(TripCategories).map(([key, category]) => (
+                    <option key={key} value={key}>
+                      {category.label}
+                    </option>
+                  ))}
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  지역 (선택사항)
+                </label>
+                <input
+                  type="text"
+                  value={formData.destination.region}
+                  onChange={(e) => setFormData({ 
+                    ...formData, 
+                    destination: { ...formData.destination, region: e.target.value }
+                  })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  placeholder="예: 규슈"
+                />
+              </div>
+
+              <div className="md:col-span-2">
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  설명 (선택사항)
+                </label>
+                <textarea
+                  value={formData.description}
+                  onChange={(e) => setFormData({ ...formData, description: e.target.value })}
+                  className="w-full px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                  rows={3}
+                  placeholder="여행에 대한 간단한 설명을 입력하세요"
+                />
+              </div>
+
+              <div className="md:col-span-2">
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  태그 (선택사항)
+                </label>
+                <div className="flex gap-2 mb-2">
+                  <input
+                    type="text"
+                    value={tagInput}
+                    onChange={(e) => setTagInput(e.target.value)}
+                    onKeyPress={(e) => e.key === 'Enter' && (e.preventDefault(), addTag())}
+                    className="flex-1 px-3 py-2 border border-gray-300 rounded focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+                    placeholder="태그를 입력하고 Enter를 누르세요"
+                  />
+                  <button
+                    type="button"
+                    onClick={addTag}
+                    className="px-4 py-2 bg-gray-100 text-gray-700 rounded hover:bg-gray-200"
+                  >
+                    추가
+                  </button>
+                </div>
+                {formData.tags && formData.tags.length > 0 && (
+                  <div className="flex flex-wrap gap-2">
+                    {formData.tags.map((tag) => (
+                      <span
+                        key={tag}
+                        className="inline-flex items-center px-2 py-1 bg-blue-100 text-blue-800 text-sm rounded"
+                      >
+                        {tag}
+                        <button
+                          type="button"
+                          onClick={() => removeTag(tag)}
+                          className="ml-1 text-blue-600 hover:text-blue-800"
+                        >
+                          ×
+                        </button>
+                      </span>
+                    ))}
+                  </div>
+                )}
+              </div>
+
+              <div className="md:col-span-2">
+                <label className="flex items-center gap-2">
+                  <input
+                    type="checkbox"
+                    checked={formData.is_public}
+                    onChange={(e) => setFormData({ ...formData, is_public: e.target.checked })}
+                    className="rounded"
+                  />
+                  <span className="text-sm font-medium text-gray-700">
+                    다른 사용자에게 공개 (템플릿으로 활용 가능)
+                  </span>
+                </label>
+              </div>
+            </div>
+            
+            <div className="flex gap-2 pt-4">
+              <button
+                type="button"
+                onClick={onClose}
+                className="flex-1 px-4 py-2 border border-gray-300 text-gray-700 rounded hover:bg-gray-50"
+              >
+                취소
+              </button>
+              <button
+                type="submit"
+                disabled={isSubmitting}
+                className="flex-1 px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700 disabled:opacity-50"
+              >
+                {isSubmitting ? '생성 중...' : '여행 계획 만들기'}
+              </button>
+            </div>
+          </form>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default UserDashboard
diff --git a/src/components/forms/CoordinateInput.tsx b/src/components/forms/CoordinateInput.tsx
new file mode 100644
index 0000000..51abadc
--- /dev/null
+++ b/src/components/forms/CoordinateInput.tsx
@@ -0,0 +1,58 @@
+interface CoordinateInputProps {
+  coordinates: { lat: number; lng: number } | null | undefined
+  onChange: (coords: { lat: number; lng: number } | null) => void
+  className?: string
+}
+
+const CoordinateInput = ({ coordinates, onChange, className = '' }: CoordinateInputProps) => {
+  return (
+    <div className={className}>
+      <label className="block text-sm font-medium text-gray-700 mb-1">
+        좌표 (Google Maps에서 복사)
+      </label>
+      <div className="grid grid-cols-2 gap-3">
+        <input
+          type="number"
+          step="0.0001"
+          placeholder="위도 (예: 32.8817)"
+          value={coordinates?.lat !== undefined && coordinates?.lat !== 0 ? coordinates.lat : ''}
+          onChange={(e) => {
+            const value = e.target.value
+            if (value === '') {
+              onChange(null)
+            } else {
+              const lat = parseFloat(value)
+              if (!isNaN(lat)) {
+                onChange({ lat, lng: coordinates?.lng || 0 })
+              }
+            }
+          }}
+          className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+        />
+        <input
+          type="number"
+          step="0.0001"
+          placeholder="경도 (예: 131.0126)"
+          value={coordinates?.lng !== undefined && coordinates?.lng !== 0 ? coordinates.lng : ''}
+          onChange={(e) => {
+            const value = e.target.value
+            if (value === '') {
+              onChange(null)
+            } else {
+              const lng = parseFloat(value)
+              if (!isNaN(lng)) {
+                onChange({ lat: coordinates?.lat || 0, lng })
+              }
+            }
+          }}
+          className="w-full px-4 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent"
+        />
+      </div>
+      <p className="text-xs text-gray-500 mt-1">
+        💡 Google Maps에서 장소 우클릭 → 좌표 복사
+      </p>
+    </div>
+  )
+}
+
+export default CoordinateInput
diff --git a/src/components/forms/ImageUploadField.tsx b/src/components/forms/ImageUploadField.tsx
new file mode 100644
index 0000000..4aaff80
--- /dev/null
+++ b/src/components/forms/ImageUploadField.tsx
@@ -0,0 +1,103 @@
+import { useState } from 'react'
+
+interface ImageUploadFieldProps {
+  images: string[]
+  onChange: (images: string[]) => void
+  maxImages?: number
+  className?: string
+}
+
+const ImageUploadField = ({
+  images,
+  onChange,
+  maxImages = 5,
+  className = ''
+}: ImageUploadFieldProps) => {
+  const [uploading, setUploading] = useState(false)
+
+  const handleImageUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const files = e.target.files
+    if (!files || files.length === 0) return
+
+    setUploading(true)
+    try {
+      const formData = new FormData()
+      Array.from(files).forEach(file => {
+        formData.append('images', file)
+      })
+
+      const response = await fetch('http://localhost:3000/api/uploads', {
+        method: 'POST',
+        body: formData
+      })
+
+      if (!response.ok) {
+        throw new Error('이미지 업로드 실패')
+      }
+
+      const result = await response.json()
+      onChange([...images, ...result.files])
+    } catch (error) {
+      console.error('이미지 업로드 오류:', error)
+      alert('이미지 업로드에 실패했습니다.')
+    } finally {
+      setUploading(false)
+    }
+  }
+
+  const handleImageDelete = (index: number) => {
+    const updatedImages = [...images]
+    updatedImages.splice(index, 1)
+    onChange(updatedImages)
+  }
+
+  return (
+    <div className={className}>
+      <label className="block text-sm font-medium text-gray-700 mb-2">
+        📷 사진 업로드
+      </label>
+
+      {/* 이미지 미리보기 */}
+      {images.length > 0 && (
+        <div className="grid grid-cols-3 gap-2 mb-3">
+          {images.map((img, idx) => (
+            <div key={idx} className="relative group">
+              <img
+                src={`http://localhost:3000${img}`}
+                alt={`이미지 ${idx + 1}`}
+                className="w-full h-20 object-cover rounded border border-gray-200"
+              />
+              <button
+                type="button"
+                onClick={() => handleImageDelete(idx)}
+                className="absolute top-1 right-1 bg-red-500 text-white rounded-full w-5 h-5 flex items-center justify-center opacity-0 group-hover:opacity-100 transition-opacity text-xs"
+              >
+                ×
+              </button>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {/* 업로드 버튼 */}
+      <label className="cursor-pointer block">
+        <div className="px-4 py-2 bg-purple-50 border-2 border-purple-200 text-purple-700 rounded-lg hover:bg-purple-100 transition-colors text-center text-sm font-medium">
+          {uploading ? '업로드 중...' : `+ 이미지 추가 (최대 ${maxImages}개)`}
+        </div>
+        <input
+          type="file"
+          accept="image/*"
+          multiple
+          onChange={handleImageUpload}
+          disabled={uploading}
+          className="hidden"
+        />
+      </label>
+      <p className="text-xs text-gray-500 mt-2">
+        💡 Trip 페이지 지도에 표시됩니다
+      </p>
+    </div>
+  )
+}
+
+export default ImageUploadField
diff --git a/src/components/forms/LinkManagement.tsx b/src/components/forms/LinkManagement.tsx
new file mode 100644
index 0000000..50014f7
--- /dev/null
+++ b/src/components/forms/LinkManagement.tsx
@@ -0,0 +1,177 @@
+import { useState } from 'react'
+import { Link } from '../../types'
+
+interface LinkManagementProps {
+  links: Link[]
+  onChange: (links: Link[]) => void
+  className?: string
+}
+
+const LinkManagement = ({ links, onChange, className = '' }: LinkManagementProps) => {
+  const [newLink, setNewLink] = useState('')
+  const [newLinkLabel, setNewLinkLabel] = useState('')
+  const [editingLinkIndex, setEditingLinkIndex] = useState<number | null>(null)
+
+  const handleAddLink = () => {
+    if (!newLink.trim()) return
+
+    const link = {
+      url: newLink.trim(),
+      label: newLinkLabel.trim() || undefined
+    }
+
+    onChange([...links, link])
+    setNewLink('')
+    setNewLinkLabel('')
+  }
+
+  const handleEditLink = (index: number) => {
+    const link = links[index]
+    if (link) {
+      setNewLink(link.url)
+      setNewLinkLabel(link.label || '')
+      setEditingLinkIndex(index)
+    }
+  }
+
+  const handleUpdateLink = () => {
+    if (editingLinkIndex === null || !newLink.trim()) return
+
+    const updatedLinks = [...links]
+    updatedLinks[editingLinkIndex] = {
+      url: newLink.trim(),
+      label: newLinkLabel.trim() || undefined
+    }
+
+    onChange(updatedLinks)
+    setNewLink('')
+    setNewLinkLabel('')
+    setEditingLinkIndex(null)
+  }
+
+  const handleCancelEditLink = () => {
+    setNewLink('')
+    setNewLinkLabel('')
+    setEditingLinkIndex(null)
+  }
+
+  const handleDeleteLink = (index: number) => {
+    const updatedLinks = [...links]
+    updatedLinks.splice(index, 1)
+    onChange(updatedLinks)
+    if (editingLinkIndex === index) {
+      setEditingLinkIndex(null)
+      setNewLink('')
+      setNewLinkLabel('')
+    }
+  }
+
+  return (
+    <div className={className}>
+      <label className="block text-sm font-medium text-gray-700 mb-2">
+        🔗 관련 링크
+      </label>
+
+      {/* 링크 목록 */}
+      {links.length > 0 && (
+        <div className="space-y-2 mb-3">
+          {links.map((link, idx) => (
+            <div key={idx} className="flex items-center gap-2 bg-blue-50 p-2 rounded">
+              <a
+                href={link.url}
+                target="_blank"
+                rel="noopener noreferrer"
+                className="flex-1 text-xs text-blue-600 hover:underline truncate"
+              >
+                {link.label || link.url}
+              </a>
+              <button
+                type="button"
+                onClick={() => handleEditLink(idx)}
+                className="px-2 py-1 bg-blue-100 text-blue-700 hover:bg-blue-200 rounded text-xs"
+              >
+                편집
+              </button>
+              <button
+                type="button"
+                onClick={() => handleDeleteLink(idx)}
+                className="px-2 py-1 bg-red-100 text-red-700 hover:bg-red-200 rounded text-xs"
+              >
+                삭제
+              </button>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {/* 링크 입력/편집 폼 */}
+      <div className="space-y-2">
+        {editingLinkIndex !== null && (
+          <div className="text-xs text-amber-700 bg-amber-50 px-2 py-1 rounded">
+            ✏️ 링크 편집 중...
+          </div>
+        )}
+        <input
+          type="text"
+          value={newLinkLabel}
+          onChange={(e) => setNewLinkLabel(e.target.value)}
+          onKeyPress={(e) => {
+            if (e.key === 'Enter') {
+              e.preventDefault()
+              document.getElementById('link-url-input')?.focus()
+            }
+          }}
+          placeholder="링크 설명 (선택, 예: 공식 홈페이지)"
+          className="w-full px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent text-sm"
+        />
+        <div className="flex gap-2">
+          <input
+            id="link-url-input"
+            type="url"
+            value={newLink}
+            onChange={(e) => setNewLink(e.target.value)}
+            onKeyPress={(e) => {
+              if (e.key === 'Enter') {
+                e.preventDefault()
+                editingLinkIndex !== null ? handleUpdateLink() : handleAddLink()
+              }
+            }}
+            placeholder="https://example.com"
+            className="flex-1 px-3 py-2 border border-gray-300 rounded-lg focus:ring-2 focus:ring-kumamoto-primary focus:border-transparent text-sm"
+          />
+          {editingLinkIndex !== null ? (
+            <>
+              <button
+                type="button"
+                onClick={handleUpdateLink}
+                className="px-4 py-2 bg-green-500 text-white rounded-lg hover:bg-green-600 transition-colors text-sm font-medium"
+              >
+                수정
+              </button>
+              <button
+                type="button"
+                onClick={handleCancelEditLink}
+                className="px-4 py-2 bg-gray-300 text-gray-700 rounded-lg hover:bg-gray-400 transition-colors text-sm font-medium"
+              >
+                취소
+              </button>
+            </>
+          ) : (
+            <button
+              type="button"
+              onClick={handleAddLink}
+              className="px-4 py-2 bg-blue-500 text-white rounded-lg hover:bg-blue-600 transition-colors text-sm font-medium"
+            >
+              추가
+            </button>
+          )}
+        </div>
+      </div>
+      <p className="text-xs text-gray-500 mt-2">
+        💡 링크 설명을 입력하지 않으면 URL이 그대로 표시됩니다
+      </p>
+    </div>
+  )
+}
+
+export default LinkManagement
diff --git a/src/components/forms/LocationSelector.tsx b/src/components/forms/LocationSelector.tsx
new file mode 100644
index 0000000..e47e4e2
--- /dev/null
+++ b/src/components/forms/LocationSelector.tsx
@@ -0,0 +1,139 @@
+import { useState, useEffect } from 'react'
+import { BasePoint } from '../../types'
+import { basePointsAPI } from '../../services/api'
+import CoordinateInput from './CoordinateInput'
+
+interface LocationSelectorProps {
+  location?: string
+  coordinates?: { lat: number; lng: number } | null
+  onLocationChange: (location: string) => void
+  onCoordinatesChange: (coords: { lat: number; lng: number } | null) => void
+  className?: string
+}
+
+const LocationSelector = ({
+  location,
+  coordinates,
+  onLocationChange,
+  onCoordinatesChange,
+  className = ''
+}: LocationSelectorProps) => {
+  const [basePoints, setBasePoints] = useState<BasePoint[]>([])
+  const [showLocationInput, setShowLocationInput] = useState<'saved' | 'new' | null>(null)
+
+  useEffect(() => {
+    loadBasePoints()
+  }, [])
+
+  const loadBasePoints = async () => {
+    try {
+      const points = await basePointsAPI.getAll()
+      setBasePoints(points)
+    } catch (error) {
+      console.error('Failed to load base points:', error)
+    }
+  }
+
+  const selectBasePoint = (point: BasePoint) => {
+    onLocationChange(point.address)
+    onCoordinatesChange({
+      lat: point.coordinates.lat,
+      lng: point.coordinates.lng,
+    })
+    setShowLocationInput(null)
+  }
+
+  return (
+    <div className={className}>
+      <label className="block text-sm font-medium text-gray-700 mb-2">
+        장소 및 위치 정보 (지도 마커 표시용)
+      </label>
+
+      {/* 저장된 주소 불러오기 또는 직접 입력 선택 */}
+      <div className="flex gap-2 mb-3">
+        <button
+          type="button"
+          onClick={() => setShowLocationInput(showLocationInput === 'saved' ? null : 'saved')}
+          className={`flex-1 px-3 py-2 rounded text-sm ${
+            showLocationInput === 'saved'
+              ? 'bg-purple-500 text-white'
+              : 'bg-purple-100 text-purple-700 hover:bg-purple-200'
+          }`}
+        >
+          📍 저장된 주소
+        </button>
+        <button
+          type="button"
+          onClick={() => setShowLocationInput(showLocationInput === 'new' ? null : 'new')}
+          className={`flex-1 px-3 py-2 rounded text-sm ${
+            showLocationInput === 'new'
+              ? 'bg-blue-500 text-white'
+              : 'bg-blue-100 text-blue-700 hover:bg-blue-200'
+          }`}
+        >
+          ➕ 직접 입력
+        </button>
+      </div>
+
+      {/* 저장된 주소 목록 */}
+      {showLocationInput === 'saved' && basePoints.length > 0 && (
+        <div className="mb-3 max-h-40 overflow-y-auto border rounded bg-white">
+          {basePoints.map((point) => (
+            <button
+              key={point.id}
+              type="button"
+              onClick={() => selectBasePoint(point)}
+              className="w-full text-left px-3 py-2 hover:bg-gray-100 border-b last:border-b-0"
+            >
+              <div className="font-medium text-sm text-gray-800">
+                {point.type === 'accommodation' ? '🏨' :
+                 point.type === 'airport' ? '✈️' :
+                 point.type === 'station' ? '🚉' :
+                 point.type === 'parking' ? '🅿️' : '📍'} {point.name}
+              </div>
+              <div className="text-xs text-gray-500 truncate">{point.address}</div>
+            </button>
+          ))}
+        </div>
+      )}
+
+      {showLocationInput === 'saved' && basePoints.length === 0 && (
+        <p className="text-sm text-gray-500 italic mb-3">
+          저장된 주소가 없습니다. 구마모토 지도에서 기본 정보를 먼저 추가해주세요.
+        </p>
+      )}
+
+      {/* 직접 입력 */}
+      {showLocationInput === 'new' && (
+        <div className="space-y-2 mb-3">
+          <input
+            type="text"
+            value={location || ''}
+            onChange={(e) => onLocationChange(e.target.value)}
+            className="w-full px-3 py-2 border rounded text-sm"
+            placeholder="주소를 입력하세요"
+          />
+          <CoordinateInput
+            coordinates={coordinates}
+            onChange={onCoordinatesChange}
+          />
+        </div>
+      )}
+
+      {/* 현재 선택된 정보 표시 */}
+      {(location || coordinates) && (
+        <div className="p-2 bg-green-50 border border-green-200 rounded text-xs">
+          {location && <div>📍 {location}</div>}
+          {coordinates && coordinates.lat !== 0 && coordinates.lng !== 0 && (
+            <div className="text-green-700">
+              ✓ 좌표: {coordinates.lat.toFixed(4)}, {coordinates.lng.toFixed(4)}
+              <div className="text-green-600 mt-1">→ Trip 페이지 지도에 마커로 표시됩니다</div>
+            </div>
+          )}
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default LocationSelector
diff --git a/src/constants/defaultData.ts b/src/constants/defaultData.ts
new file mode 100644
index 0000000..ef64ed3
--- /dev/null
+++ b/src/constants/defaultData.ts
@@ -0,0 +1,232 @@
+import { TravelPlan } from '../types'
+
+/**
+ * 기본 여행 계획 데이터 (샘플 구마모토 여행)
+ * 새로운 사용자를 위한 템플릿
+ */
+export const defaultTravelPlan: TravelPlan = {
+  id: 'legacy_kumamoto_trip',
+  title: '구마모토 3박 4일 여행',
+  description: '아소산과 구마모토성을 중심으로 한 규슈 여행',
+  destination: {
+    country: '일본',
+    city: '구마모토',
+    region: '규슈',
+    coordinates: { lat: 32.7898, lng: 130.7417 }
+  },
+  startDate: new Date('2026-02-17'),
+  endDate: new Date('2026-02-20'),
+  schedule: [
+    {
+      date: new Date('2026-02-18'),
+      activities: [
+        {
+          id: '1',
+          time: '09:00',
+          title: '렌트카 픽업',
+          description: '렌트카로 이동',
+          type: 'transport',
+        },
+        {
+          id: '2',
+          time: '10:00',
+          title: '기쿠치협곡',
+          description: '렌트카로 이동',
+          location: '기쿠치시',
+          type: 'attraction',
+          relatedPlaces: [
+            {
+              id: 'rp-2-1',
+              name: '기쿠치 온천',
+              description: '기쿠치협곡 인근의 유명 온천 지역. 피로 회복에 좋음',
+              address: '熊本県菊池市隈府',
+              coordinates: { lat: 32.9785, lng: 130.8145 },
+              memo: '협곡 방문 후 온천 추천'
+            },
+            {
+              id: 'rp-2-2',
+              name: '기쿠치 공원',
+              description: '벚꽃 명소로 유명한 공원. 약 3,000그루의 벚나무',
+              address: '熊本県菊池市隈府',
+              coordinates: { lat: 32.9795, lng: 130.8115 },
+              memo: '봄철 벚꽃 시즌 추천'
+            },
+            {
+              id: 'rp-2-3',
+              name: '기쿠치 시립 천문대',
+              description: '맑은 날 별 관측이 가능한 천문대',
+              address: '熊本県菊池市旭志',
+              coordinates: { lat: 32.9523, lng: 130.8789 },
+              memo: '저녁 시간대 방문 가능'
+            }
+          ]
+        },
+        {
+          id: '3',
+          time: '12:00',
+          title: '쿠사센리',
+          description: '렌트카로 이동',
+          location: '아소시',
+          type: 'attraction',
+          relatedPlaces: [
+            {
+              id: 'rp-3-1',
+              name: '아소 화산 박물관',
+              description: '아소산의 화산 활동과 역사를 전시하는 박물관',
+              address: '熊本県阿蘇市赤水',
+              coordinates: { lat: 32.8817, lng: 131.0126 },
+              memo: '쿠사센리 바로 옆에 위치'
+            },
+            {
+              id: 'rp-3-2',
+              name: '고마야마',
+              description: '쿠사센리 초원에서 볼 수 있는 작은 화산 언덕',
+              address: '熊本県阿蘇市',
+              coordinates: { lat: 32.8856, lng: 131.0105 },
+              memo: '승마 체험 가능'
+            },
+            {
+              id: 'rp-3-3',
+              name: '다카다케 등산로 입구',
+              description: '아소 오악 중 하나인 다카다케 등산로 시작점',
+              address: '熊本県阿蘇市',
+              coordinates: { lat: 32.8923, lng: 131.0234 },
+              memo: '등산 시간: 왕복 약 3-4시간'
+            }
+          ]
+        },
+        {
+          id: '4',
+          time: '14:00',
+          title: '아소산',
+          description: '렌트카로 이동',
+          location: '아소시',
+          type: 'attraction',
+          relatedPlaces: [
+            {
+              id: 'rp-4-1',
+              name: '나카다케 분화구',
+              description: '아소산의 활화산 분화구. 에메랄드빛 화구호',
+              address: '熊本県阿蘇市黒川',
+              coordinates: { lat: 32.8847, lng: 131.0897 },
+              memo: '화산 활동 상황에 따라 접근 제한 가능'
+            },
+            {
+              id: 'rp-4-2',
+              name: '아소산 로프웨이',
+              description: '분화구까지 이동하는 로프웨이 (운영 중단 시 셔틀버스 이용)',
+              address: '熊本県阿蘇市黒川',
+              coordinates: { lat: 32.8835, lng: 131.0785 },
+              memo: '날씨와 화산 활동 상황 확인 필요'
+            },
+            {
+              id: 'rp-4-3',
+              name: '우치노마키 온천',
+              description: '아소산 북쪽 기슭의 온천 마을',
+              address: '熊本県阿蘇市内牧',
+              coordinates: { lat: 32.9112, lng: 131.0523 },
+              memo: '등산 후 휴식 추천'
+            },
+            {
+              id: 'rp-4-4',
+              name: '아소 신사',
+              description: '2,500년 역사의 신사. 2016년 지진 피해 복구 중',
+              address: '熊本県阿蘇市一の宮町宮地',
+              coordinates: { lat: 32.9478, lng: 131.0267 },
+              memo: '아소 지역의 대표 신사'
+            }
+          ]
+        },
+        {
+          id: '5',
+          time: '16:00',
+          title: '사라카와수원',
+          description: '렌트카로 이동',
+          location: '구마모토시',
+          type: 'attraction',
+          relatedPlaces: [
+            {
+              id: 'rp-5-1',
+              name: '남아소 수원 공원',
+              description: '맑은 지하수가 솟아나는 자연 공원',
+              address: '熊本県阿蘇郡南阿蘇村白川',
+              coordinates: { lat: 32.8345, lng: 131.0456 },
+              memo: '수원 산책로 및 물놀이 가능'
+            },
+            {
+              id: 'rp-5-2',
+              name: '미후네 마치 공룡 박물관',
+              description: '화석 발굴 체험이 가능한 공룡 박물관',
+              address: '熊本県上益城郡御船町',
+              coordinates: { lat: 32.7123, lng: 130.8034 },
+              memo: '어린이 동반 추천'
+            },
+            {
+              id: 'rp-5-3',
+              name: '에코파크 수원의 숲',
+              description: '산책로와 자연 학습 시설이 있는 생태 공원',
+              address: '熊本県阿蘇郡南阿蘇村',
+              coordinates: { lat: 32.8267, lng: 131.0389 },
+              memo: '가족 단위 산책 코스'
+            }
+          ]
+        },
+      ],
+    },
+    {
+      date: new Date('2026-02-19'),
+      activities: [
+        {
+          id: '6',
+          time: '09:00',
+          title: '구마모토성',
+          description: '대중교통으로 이동',
+          location: '구마모토시 주오구',
+          type: 'attraction',
+        },
+        {
+          id: '7',
+          time: '11:30',
+          title: '사쿠라노바바',
+          description: '대중교통으로 이동',
+          location: '구마모토시',
+          type: 'attraction',
+        },
+        {
+          id: '8',
+          time: '14:00',
+          title: '스이젠지조주엔',
+          description: '대중교통으로 이동',
+          location: '구마모토시 주오구',
+          type: 'attraction',
+        },
+        {
+          id: '9',
+          time: '16:00',
+          title: '시모토리아케이드',
+          description: '대중교통으로 이동',
+          location: '구마모토시',
+          type: 'attraction',
+        },
+      ],
+    },
+  ],
+  budget: {
+    total: 0,
+    accommodation: 0,
+    food: 0,
+    transportation: 0,
+    shopping: 0,
+    activities: 0,
+  },
+  checklist: [],
+  // 새로운 필드들
+  user_id: 'system',
+  created_at: '2024-01-01T00:00:00.000Z',
+  updated_at: '2024-01-01T00:00:00.000Z',
+  is_public: true,
+  is_template: true,
+  template_category: 'japan',
+  tags: ['온천', '자연', '역사', '맛집'],
+  status: 'completed'
+}
diff --git a/src/data/tripTemplates.ts b/src/data/tripTemplates.ts
new file mode 100644
index 0000000..ee4c028
--- /dev/null
+++ b/src/data/tripTemplates.ts
@@ -0,0 +1,590 @@
+// 도시별 여행 템플릿 데이터
+import { TravelPlan, Activity, DaySchedule } from '../types'
+
+export interface TripTemplate {
+  id: string
+  title: string
+  description: string
+  destination: {
+    country: string
+    city: string
+    region?: string
+    coordinates: {
+      lat: number
+      lng: number
+    }
+  }
+  category: 'japan' | 'korea' | 'asia' | 'europe' | 'america' | 'other'
+  duration: number // 추천 일수
+  season: string[] // 추천 계절
+  tags: string[]
+  difficulty: 'easy' | 'medium' | 'hard'
+  budget_range: {
+    min: number
+    max: number
+    currency: 'KRW' | 'JPY' | 'USD'
+  }
+  highlights: string[] // 주요 볼거리
+  thumbnail: string
+  sample_schedule: DaySchedule[]
+  tips: string[]
+  best_time: string
+  transportation: string[]
+}
+
+// 구마모토 템플릿
+export const kumamotoTemplate: TripTemplate = {
+  id: 'kumamoto_3d4n',
+  title: '구마모토 3박 4일 완벽 가이드',
+  description: '구마모토성부터 아소산까지, 규슈의 숨은 보석을 만나는 여행',
+  destination: {
+    country: '일본',
+    city: '구마모토',
+    region: '규슈',
+    coordinates: { lat: 32.7898, lng: 130.7417 }
+  },
+  category: 'japan',
+  duration: 4,
+  season: ['봄', '가을'],
+  tags: ['온천', '자연', '역사', '맛집', '구마몬'],
+  difficulty: 'easy',
+  budget_range: {
+    min: 800000,
+    max: 1200000,
+    currency: 'KRW'
+  },
+  highlights: [
+    '구마모토성 - 일본 3대 명성 중 하나',
+    '아소산 - 세계 최대급 칼데라',
+    '구로카와 온천 - 정통 온천 마을',
+    '구마모토 라멘 - 마늘과 돈코츠의 조화'
+  ],
+  thumbnail: 'https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=400&q=80',
+  sample_schedule: [
+    {
+      date: new Date('2024-02-17'),
+      activities: [
+        {
+          id: 'day1_1',
+          time: '09:00',
+          title: '후쿠오카 공항 도착',
+          description: '후쿠오카 공항에서 구마모토로 이동',
+          location: '후쿠오카 공항',
+          type: 'transport',
+          coordinates: { lat: 33.5859, lng: 130.4507 }
+        },
+        {
+          id: 'day1_2',
+          time: '12:00',
+          title: '구마모토성 관람',
+          description: '일본 3대 명성 중 하나인 구마모토성 탐방',
+          location: '구마모토성',
+          type: 'attraction',
+          coordinates: { lat: 32.8064, lng: 130.7056 }
+        },
+        {
+          id: 'day1_3',
+          time: '15:00',
+          title: '사쿠라노바바 조사이엔',
+          description: '구마모토의 역사와 문화를 체험할 수 있는 복합시설',
+          location: '사쿠라노바바 조사이엔',
+          type: 'attraction',
+          coordinates: { lat: 32.8070, lng: 130.7060 }
+        },
+        {
+          id: 'day1_4',
+          time: '18:00',
+          title: '구마모토 라멘 저녁식사',
+          description: '마늘과 돈코츠 스프의 진한 맛',
+          location: '라멘 요코초',
+          type: 'food',
+          coordinates: { lat: 32.7898, lng: 130.7417 }
+        }
+      ]
+    },
+    {
+      date: new Date('2024-02-18'),
+      activities: [
+        {
+          id: 'day2_1',
+          time: '08:00',
+          title: '렌터카 픽업',
+          description: '아소 지역 관광을 위한 렌터카 대여',
+          location: '구마모토역 렌터카',
+          type: 'transport',
+          coordinates: { lat: 32.789827, lng: 130.741667 }
+        },
+        {
+          id: 'day2_2',
+          time: '10:00',
+          title: '기쿠치 협곡',
+          description: '에메랄드빛 계곡과 폭포의 절경',
+          location: '기쿠치 협곡',
+          type: 'attraction',
+          coordinates: { lat: 32.985, lng: 130.856 }
+        },
+        {
+          id: 'day2_3',
+          time: '13:00',
+          title: '쿠사센리 초원',
+          description: '아소산 기슭의 광활한 초원',
+          location: '쿠사센리',
+          type: 'attraction',
+          coordinates: { lat: 32.8856, lng: 131.0105 }
+        },
+        {
+          id: 'day2_4',
+          time: '15:30',
+          title: '아소산 화구 견학',
+          description: '활화산의 웅장한 화구를 직접 체험',
+          location: '아소산',
+          type: 'attraction',
+          coordinates: { lat: 32.8847, lng: 131.0897 }
+        },
+        {
+          id: 'day2_5',
+          time: '17:00',
+          title: '구로카와 온천 체크인',
+          description: '전통 온천 료칸에서의 힐링 타임',
+          location: '구로카와 온천',
+          type: 'accommodation',
+          coordinates: { lat: 33.0564, lng: 131.1175 }
+        }
+      ]
+    },
+    {
+      date: new Date('2024-02-19'),
+      activities: [
+        {
+          id: 'day3_1',
+          time: '09:00',
+          title: '온천 료칸 조식',
+          description: '전통 일식 조식과 노천온천',
+          location: '구로카와 온천 료칸',
+          type: 'food',
+          coordinates: { lat: 33.0564, lng: 131.1175 }
+        },
+        {
+          id: 'day3_2',
+          time: '11:00',
+          title: '시라카와 수원',
+          description: '일본 명수 100선의 맑은 용천수',
+          location: '시라카와 수원',
+          type: 'attraction',
+          coordinates: { lat: 32.885833, lng: 130.879444 }
+        },
+        {
+          id: 'day3_3',
+          time: '14:00',
+          title: '스이젠지 조주엔',
+          description: '미니어처 후지산이 있는 일본 정원',
+          location: '스이젠지 조주엔',
+          type: 'attraction',
+          coordinates: { lat: 32.784722, lng: 130.743889 }
+        },
+        {
+          id: 'day3_4',
+          time: '16:00',
+          title: '시모토리 아케이드 쇼핑',
+          description: '구마모토 최대 번화가에서 쇼핑과 간식',
+          location: '시모토리 아케이드',
+          type: 'other',
+          coordinates: { lat: 32.799167, lng: 130.711667 }
+        }
+      ]
+    },
+    {
+      date: new Date('2024-02-20'),
+      activities: [
+        {
+          id: 'day4_1',
+          time: '10:00',
+          title: '구마몬 스퀘어',
+          description: '구마모토 마스코트 구마몬의 공식 매장',
+          location: '구마몬 스퀘어',
+          type: 'other',
+          coordinates: { lat: 32.7898, lng: 130.7417 }
+        },
+        {
+          id: 'day4_2',
+          time: '12:00',
+          title: '마지막 구마모토 라멘',
+          description: '여행의 마무리를 장식하는 라멘',
+          location: '구마모토역 라멘',
+          type: 'food',
+          coordinates: { lat: 32.789827, lng: 130.741667 }
+        },
+        {
+          id: 'day4_3',
+          time: '14:00',
+          title: '후쿠오카 공항 출발',
+          description: '구마모토에서 후쿠오카 공항으로 이동',
+          location: '후쿠오카 공항',
+          type: 'transport',
+          coordinates: { lat: 33.5859, lng: 130.4507 }
+        }
+      ]
+    }
+  ],
+  tips: [
+    '렌터카 예약은 미리 해두세요 (특히 성수기)',
+    '아소산 화구는 날씨에 따라 출입이 제한될 수 있습니다',
+    '구로카와 온천은 료칸 예약이 필수입니다',
+    '구마모토 라멘은 마늘이 많이 들어가니 참고하세요',
+    'JR 규슈 패스를 활용하면 교통비를 절약할 수 있습니다'
+  ],
+  best_time: '3월-5월 (벚꽃), 9월-11월 (단풍)',
+  transportation: ['렌터카', 'JR 규슈선', '고속버스']
+}
+
+// 도쿄 템플릿
+export const tokyoTemplate: TripTemplate = {
+  id: 'tokyo_4d5n',
+  title: '도쿄 4박 5일 완전정복',
+  description: '전통과 현대가 공존하는 일본의 수도 도쿄 완전 가이드',
+  destination: {
+    country: '일본',
+    city: '도쿄',
+    region: '간토',
+    coordinates: { lat: 35.6762, lng: 139.6503 }
+  },
+  category: 'japan',
+  duration: 5,
+  season: ['봄', '가을', '겨울'],
+  tags: ['도시', '쇼핑', '문화', '음식', '현대'],
+  difficulty: 'medium',
+  budget_range: {
+    min: 1500000,
+    max: 2500000,
+    currency: 'KRW'
+  },
+  highlights: [
+    '센소지 - 도쿄 최고(最古)의 사찰',
+    '시부야 스크램블 교차로 - 세계에서 가장 바쁜 교차로',
+    '츠키지 시장 - 신선한 해산물의 천국',
+    '도쿄 스카이트리 - 634m 높이의 랜드마크'
+  ],
+  thumbnail: 'https://images.unsplash.com/photo-1540959733332-eab4deabeeaf?w=400&q=80',
+  sample_schedule: [
+    {
+      date: new Date('2024-03-15'),
+      activities: [
+        {
+          id: 'tokyo_day1_1',
+          time: '09:00',
+          title: '나리타 공항 도착',
+          description: '나리타 익스프레스로 도쿄역까지 이동',
+          location: '나리타 공항',
+          type: 'transport',
+          coordinates: { lat: 35.7720, lng: 140.3929 }
+        },
+        {
+          id: 'tokyo_day1_2',
+          time: '12:00',
+          title: '아사쿠사 센소지',
+          description: '도쿄에서 가장 오래된 사찰 탐방',
+          location: '센소지',
+          type: 'attraction',
+          coordinates: { lat: 35.7148, lng: 139.7967 }
+        },
+        {
+          id: 'tokyo_day1_3',
+          time: '15:00',
+          title: '도쿄 스카이트리',
+          description: '634m 높이에서 바라보는 도쿄 전경',
+          location: '도쿄 스카이트리',
+          type: 'attraction',
+          coordinates: { lat: 35.7101, lng: 139.8107 }
+        },
+        {
+          id: 'tokyo_day1_4',
+          time: '18:00',
+          title: '스시 저녁식사',
+          description: '긴자의 정통 스시 오마카세',
+          location: '긴자',
+          type: 'food',
+          coordinates: { lat: 35.6717, lng: 139.7640 }
+        }
+      ]
+    }
+    // 추가 일정들...
+  ],
+  tips: [
+    'JR 패스를 미리 구매하면 교통비를 크게 절약할 수 있습니다',
+    '러시아워(7-9시, 17-19시)에는 지하철이 매우 혼잡합니다',
+    '현금 사용이 많으니 충분한 엔화를 준비하세요',
+    '구글 번역 앱을 설치해두면 도움이 됩니다'
+  ],
+  best_time: '3월-5월 (벚꽃), 9월-11월 (단풍)',
+  transportation: ['JR 야마노테선', '지하철', '택시']
+}
+
+// 오사카 템플릿
+export const osakaTemplate: TripTemplate = {
+  id: 'osaka_3d4n',
+  title: '오사카 3박 4일 미식여행',
+  description: '일본의 부엌 오사카에서 즐기는 최고의 먹거리 여행',
+  destination: {
+    country: '일본',
+    city: '오사카',
+    region: '간사이',
+    coordinates: { lat: 34.6937, lng: 135.5023 }
+  },
+  category: 'japan',
+  duration: 4,
+  season: ['봄', '가을'],
+  tags: ['미식', '성', '쇼핑', '엔터테인먼트'],
+  difficulty: 'easy',
+  budget_range: {
+    min: 1000000,
+    max: 1800000,
+    currency: 'KRW'
+  },
+  highlights: [
+    '오사카성 - 도요토미 히데요시의 거성',
+    '도톤보리 - 네온사인과 먹거리의 거리',
+    '유니버설 스튜디오 재팬 - 해리포터 월드',
+    '구로몬 시장 - 오사카의 부엌'
+  ],
+  thumbnail: 'https://images.unsplash.com/photo-1590559899731-a382839e5549?w=400&q=80',
+  sample_schedule: [
+    {
+      date: new Date('2024-04-10'),
+      activities: [
+        {
+          id: 'osaka_day1_1',
+          time: '10:00',
+          title: '간사이 공항 도착',
+          description: '간사이 공항에서 오사카 시내로 이동',
+          location: '간사이 공항',
+          type: 'transport',
+          coordinates: { lat: 34.4347, lng: 135.2441 }
+        },
+        {
+          id: 'osaka_day1_2',
+          time: '13:00',
+          title: '오사카성 관람',
+          description: '일본의 3대 명성 중 하나인 오사카성',
+          location: '오사카성',
+          type: 'attraction',
+          coordinates: { lat: 34.6873, lng: 135.5262 }
+        },
+        {
+          id: 'osaka_day1_3',
+          time: '16:00',
+          title: '도톤보리 거리',
+          description: '오사카의 상징적인 네온사인 거리',
+          location: '도톤보리',
+          type: 'attraction',
+          coordinates: { lat: 34.6686, lng: 135.5023 }
+        },
+        {
+          id: 'osaka_day1_4',
+          time: '18:00',
+          title: '타코야키 & 오코노미야키',
+          description: '오사카 대표 먹거리 체험',
+          location: '도톤보리 먹거리 골목',
+          type: 'food',
+          coordinates: { lat: 34.6686, lng: 135.5023 }
+        }
+      ]
+    }
+    // 추가 일정들...
+  ],
+  tips: [
+    '오사카 어메이징 패스로 관광지와 교통을 한번에 해결하세요',
+    '타코야키는 뜨거우니 조심해서 드세요',
+    '유니버설 스튜디오는 미리 티켓을 예약하세요',
+    '간사이벤(오사카 사투리)을 몇 개 배워가면 재미있어요'
+  ],
+  best_time: '3월-5월 (벚꽃), 9월-11월 (단풍)',
+  transportation: ['JR 오사카환상선', '지하철', '한큐선', '한신선']
+}
+
+// 서울 템플릿
+export const seoulTemplate: TripTemplate = {
+  id: 'seoul_3d4n',
+  title: '서울 3박 4일 완벽가이드',
+  description: '전통과 현대가 어우러진 대한민국의 수도 서울 탐방',
+  destination: {
+    country: '한국',
+    city: '서울',
+    region: '수도권',
+    coordinates: { lat: 37.5665, lng: 126.9780 }
+  },
+  category: 'korea',
+  duration: 4,
+  season: ['봄', '가을'],
+  tags: ['궁궐', '한식', '쇼핑', 'K-문화', '야경'],
+  difficulty: 'easy',
+  budget_range: {
+    min: 400000,
+    max: 800000,
+    currency: 'KRW'
+  },
+  highlights: [
+    '경복궁 - 조선왕조의 정궁',
+    '명동 - 쇼핑과 먹거리의 중심지',
+    '한강 - 서울 시민들의 휴식처',
+    'N서울타워 - 서울의 랜드마크'
+  ],
+  thumbnail: 'https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=400&q=80',
+  sample_schedule: [
+    {
+      date: new Date('2024-05-01'),
+      activities: [
+        {
+          id: 'seoul_day1_1',
+          time: '09:00',
+          title: '경복궁 관람',
+          description: '조선왕조 정궁에서 수문장 교대식 관람',
+          location: '경복궁',
+          type: 'attraction',
+          coordinates: { lat: 37.5796, lng: 126.9770 }
+        },
+        {
+          id: 'seoul_day1_2',
+          time: '12:00',
+          title: '북촌 한옥마을',
+          description: '전통 한옥이 보존된 아름다운 마을',
+          location: '북촌 한옥마을',
+          type: 'attraction',
+          coordinates: { lat: 37.5814, lng: 126.9835 }
+        },
+        {
+          id: 'seoul_day1_3',
+          time: '15:00',
+          title: '인사동 문화거리',
+          description: '전통 문화와 예술이 살아있는 거리',
+          location: '인사동',
+          type: 'attraction',
+          coordinates: { lat: 37.5715, lng: 126.9854 }
+        },
+        {
+          id: 'seoul_day1_4',
+          time: '18:00',
+          title: '한정식 저녁',
+          description: '정통 한국 전통 요리 체험',
+          location: '인사동 한정식집',
+          type: 'food',
+          coordinates: { lat: 37.5715, lng: 126.9854 }
+        }
+      ]
+    }
+    // 추가 일정들...
+  ],
+  tips: [
+    'T-money 카드로 지하철과 버스를 편리하게 이용하세요',
+    '궁궐 관람시 한복을 입으면 입장료가 무료입니다',
+    '명동과 홍대는 밤늦게까지 활기찬 곳입니다',
+    '한강 공원에서 치킨과 맥주를 즐겨보세요'
+  ],
+  best_time: '4월-6월 (봄), 9월-11월 (가을)',
+  transportation: ['지하철', '버스', '택시', '따릉이']
+}
+
+// 제주도 템플릿
+export const jejuTemplate: TripTemplate = {
+  id: 'jeju_3d4n',
+  title: '제주도 3박 4일 자연여행',
+  description: '한국의 하와이 제주도에서 만나는 아름다운 자연',
+  destination: {
+    country: '한국',
+    city: '제주',
+    region: '제주특별자치도',
+    coordinates: { lat: 33.4996, lng: 126.5312 }
+  },
+  category: 'korea',
+  duration: 4,
+  season: ['봄', '여름', '가을'],
+  tags: ['자연', '해변', '한라산', '감귤', '돌하르방'],
+  difficulty: 'medium',
+  budget_range: {
+    min: 600000,
+    max: 1200000,
+    currency: 'KRW'
+  },
+  highlights: [
+    '한라산 - 대한민국 최고봉',
+    '성산일출봉 - 유네스코 세계자연유산',
+    '우도 - 제주의 작은 섬',
+    '협재해수욕장 - 에메랄드빛 바다'
+  ],
+  thumbnail: 'https://images.unsplash.com/photo-1578662996442-48f60103fc96?w=400&q=80',
+  sample_schedule: [
+    {
+      date: new Date('2024-06-15'),
+      activities: [
+        {
+          id: 'jeju_day1_1',
+          time: '10:00',
+          title: '제주공항 도착',
+          description: '렌터카 픽업 후 여행 시작',
+          location: '제주국제공항',
+          type: 'transport',
+          coordinates: { lat: 33.5067, lng: 126.4930 }
+        },
+        {
+          id: 'jeju_day1_2',
+          time: '12:00',
+          title: '성산일출봉',
+          description: '유네스코 세계자연유산 등반',
+          location: '성산일출봉',
+          type: 'attraction',
+          coordinates: { lat: 33.4584, lng: 126.9424 }
+        },
+        {
+          id: 'jeju_day1_3',
+          time: '15:00',
+          title: '우도 관광',
+          description: '제주의 작은 섬 우도에서 자전거 여행',
+          location: '우도',
+          type: 'attraction',
+          coordinates: { lat: 33.5009, lng: 126.9505 }
+        },
+        {
+          id: 'jeju_day1_4',
+          time: '18:00',
+          title: '해산물 저녁',
+          description: '신선한 제주 바다의 맛',
+          location: '성산포 해산물 식당',
+          type: 'food',
+          coordinates: { lat: 33.4584, lng: 126.9424 }
+        }
+      ]
+    }
+    // 추가 일정들...
+  ],
+  tips: [
+    '렌터카는 필수입니다 (대중교통이 불편함)',
+    '날씨 변화가 심하니 여벌 옷을 준비하세요',
+    '한라산 등반시 등산화와 충분한 물을 준비하세요',
+    '감귤과 흑돼지는 꼭 맛보세요'
+  ],
+  best_time: '4월-6월 (봄), 9월-11월 (가을)',
+  transportation: ['렌터카', '관광버스', '택시']
+}
+
+// 전체 템플릿 목록
+export const tripTemplates: TripTemplate[] = [
+  kumamotoTemplate,
+  tokyoTemplate,
+  osakaTemplate,
+  seoulTemplate,
+  jejuTemplate
+]
+
+// 카테고리별 템플릿 필터링
+export const getTemplatesByCategory = (category: string): TripTemplate[] => {
+  return tripTemplates.filter(template => template.category === category)
+}
+
+// 템플릿 ID로 조회
+export const getTemplateById = (id: string): TripTemplate | undefined => {
+  return tripTemplates.find(template => template.id === id)
+}
+
+// 추천 템플릿 (인기순)
+export const getRecommendedTemplates = (): TripTemplate[] => {
+  return [kumamotoTemplate, tokyoTemplate, seoulTemplate, jejuTemplate, osakaTemplate]
+}
diff --git a/src/env.d.ts b/src/env.d.ts
new file mode 100644
index 0000000..e372cac
--- /dev/null
+++ b/src/env.d.ts
@@ -0,0 +1,12 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_GOOGLE_OAUTH_CLIENT_ID: string
+  readonly MODE: string
+  readonly DEV: boolean
+  readonly PROD: boolean
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
diff --git a/src/index.css b/src/index.css
index a417c42..832c652 100644
--- a/src/index.css
+++ b/src/index.css
@@ -11,3 +11,14 @@ body {
   -moz-osx-font-smoothing: grayscale;
 }
 
+/* 스크롤바 숨기기 유틸리티 */
+@layer utilities {
+  .scrollbar-hide {
+    -ms-overflow-style: none;
+    scrollbar-width: none;
+  }
+  .scrollbar-hide::-webkit-scrollbar {
+    display: none;
+  }
+}
+
diff --git a/src/pages/PlanPage.tsx b/src/pages/PlanPage.tsx
new file mode 100644
index 0000000..1d96f37
--- /dev/null
+++ b/src/pages/PlanPage.tsx
@@ -0,0 +1,278 @@
+import { useState, useEffect } from 'react'
+import { useParams, useNavigate, Link } from 'react-router-dom'
+import Header from '../components/Header'
+import Timeline from '../components/Timeline'
+import Attractions, { attractions } from '../components/Attractions'
+import UnifiedMap from '../components/UnifiedMap'
+import Budget from '../components/Budget'
+import Checklist from '../components/Checklist'
+import TravelDashboard from '../components/TravelDashboard'
+import TabNavigation from '../components/TabNavigation'
+import { TravelPlan, Activity } from '../types'
+import { tripManagerService } from '../services/tripManager'
+import { offlineSupportService } from '../services/offlineSupport'
+
+// PC용 일정 수립 페이지 - 편집 기능 중심
+function PlanPage() {
+  const { tripId } = useParams<{ tripId: string }>()
+  const navigate = useNavigate()
+  const [travelPlan, setTravelPlan] = useState<TravelPlan | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+
+  // 여행 계획 로드
+  useEffect(() => {
+    async function loadTravelPlan() {
+      if (!tripId) {
+        setError('여행 ID가 제공되지 않았습니다')
+        setIsLoading(false)
+        return
+      }
+
+      try {
+        const plan = await tripManagerService.getTrip(tripId)
+        if (plan) {
+          setTravelPlan(plan)
+        } else {
+          setError('여행 계획을 찾을 수 없습니다')
+        }
+      } catch (err) {
+        console.error('Failed to load travel plan:', err)
+        setError('여행 계획을 불러오는 중 오류가 발생했습니다')
+      } finally {
+        setIsLoading(false)
+      }
+    }
+
+    loadTravelPlan()
+  }, [tripId])
+
+  // 여행 계획 자동 저장
+  useEffect(() => {
+    if (travelPlan && !isLoading) {
+      const saveTrip = async () => {
+        try {
+          await tripManagerService.updateTrip(travelPlan.id, travelPlan)
+          await offlineSupportService.cacheTravelPlan(travelPlan)
+        } catch (error) {
+          console.error('Failed to save travel plan:', error)
+        }
+      }
+      
+      const timeoutId = setTimeout(saveTrip, 1000) // 1초 후 저장
+      return () => clearTimeout(timeoutId)
+    }
+  }, [travelPlan, isLoading])
+
+  // Places 검색 결과에서 일정에 추가하는 핸들러
+  const handleAddPlaceToItinerary = async (place: {
+    name: string
+    address: string
+    lat: number
+    lng: number
+  }) => {
+    if (!travelPlan) return
+
+    try {
+      // 현재 날짜의 스케줄을 찾거나 새로 생성
+      const today = new Date()
+      const currentDayScheduleIndex = travelPlan.schedule.findIndex(
+        (day) =>
+          new Date(day.date).toDateString() === today.toDateString()
+      )
+
+      let updatedPlan: TravelPlan
+      const newActivity: Activity = {
+        id: `activity-${Date.now()}`,
+        time: '12:00', // 기본 시간, 사용자가 수정 가능
+        title: place.name,
+        description: place.address,
+        location: place.address,
+        type: 'attraction',
+        coordinates: { lat: place.lat, lng: place.lng },
+      }
+
+      if (currentDayScheduleIndex !== -1) {
+        // 기존 날짜에 추가
+        const updatedSchedule = travelPlan.schedule.map((day, index) =>
+          index === currentDayScheduleIndex
+            ? {
+                ...day,
+                activities: [...day.activities, newActivity].sort((a, b) =>
+                  a.time.localeCompare(b.time)
+                ),
+              }
+            : day
+        )
+        updatedPlan = { ...travelPlan, schedule: updatedSchedule }
+      } else {
+        // 새 날짜 생성 (오늘 날짜)
+        const newDaySchedule = {
+          date: today,
+          activities: [newActivity],
+        }
+        updatedPlan = {
+          ...travelPlan,
+          schedule: [...travelPlan.schedule, newDaySchedule].sort(
+            (a, b) =>
+              new Date(a.date).getTime() - new Date(b.date).getTime()
+          ),
+        }
+      }
+
+      setTravelPlan(updatedPlan)
+      alert(`"${place.name}"이(가) 일정에 추가되었습니다!`)
+    } catch (error) {
+      console.error('Failed to add place to itinerary:', error)
+      alert('일정 추가에 실패했습니다')
+    }
+  }
+
+  // 기본 데이터로 리셋
+  const resetToDefault = async () => {
+    if (!travelPlan) return
+    
+    if (confirm('모든 여행 계획을 초기화하시겠습니까?\n\n⚠️ 이 작업은 되돌릴 수 없습니다.')) {
+      try {
+        const resetPlan: TravelPlan = {
+          ...travelPlan,
+          schedule: [],
+          budget: {
+            total: 0,
+            accommodation: 0,
+            food: 0,
+            transportation: 0,
+            shopping: 0,
+            activities: 0,
+          },
+          checklist: [],
+          updated_at: new Date().toISOString()
+        }
+        
+        await tripManagerService.updateTrip(travelPlan.id, resetPlan)
+        setTravelPlan(resetPlan)
+        alert('여행 계획이 초기화되었습니다')
+      } catch (error) {
+        console.error('Failed to reset:', error)
+        alert('초기화에 실패했습니다')
+      }
+    }
+  }
+
+  if (isLoading) {
+    return (
+      <div className="min-h-screen bg-kumamoto-light flex items-center justify-center">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-kumamoto-primary mx-auto mb-4"></div>
+          <div className="text-lg text-gray-600">여행 계획을 불러오는 중...</div>
+        </div>
+      </div>
+    )
+  }
+
+  if (error || !travelPlan) {
+    return (
+      <div className="min-h-screen bg-kumamoto-light flex items-center justify-center">
+        <div className="text-center">
+          <div className="text-4xl mb-4">⚠️</div>
+          <div className="text-lg font-medium text-gray-800 mb-2">
+            {error || '여행 계획을 찾을 수 없습니다'}
+          </div>
+          <div className="text-gray-600 mb-4">
+            다시 시도하거나 메인 페이지로 돌아가세요
+          </div>
+          <div className="flex gap-3 justify-center">
+            <button
+              onClick={() => window.location.reload()}
+              className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+            >
+              다시 시도
+            </button>
+            <Link
+              to="/"
+              className="px-4 py-2 bg-gray-600 text-white rounded hover:bg-gray-700"
+            >
+              메인으로 돌아가기
+            </Link>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="min-h-screen bg-kumamoto-light">
+      <Header />
+
+      {/* 뒤로가기 및 모바일 모드 버튼 */}
+      <div className="bg-white border-b border-gray-200 px-4 py-3">
+        <div className="max-w-7xl mx-auto flex items-center justify-between">
+          <div className="flex items-center gap-4">
+            <Link
+              to="/"
+              className="flex items-center gap-2 text-gray-600 hover:text-gray-800"
+            >
+              ← 여행 목록으로 돌아가기
+            </Link>
+            <div className="text-gray-300">|</div>
+            <h1 className="text-xl font-semibold text-gray-800">
+              {travelPlan.title}
+            </h1>
+            <span className="text-sm text-gray-500">
+              📍 {travelPlan.destination.city}, {travelPlan.destination.country}
+            </span>
+          </div>
+          
+          <div className="flex items-center gap-3">
+            <Link
+              to={`/trip/${travelPlan.id}`}
+              className="px-4 py-2 bg-green-600 text-white rounded hover:bg-green-700 flex items-center gap-2"
+            >
+              🗺️ 여행 모드
+            </Link>
+          </div>
+        </div>
+      </div>
+
+      <main className="container mx-auto px-4 py-8">
+        <TravelDashboard travelPlan={travelPlan} onReset={resetToDefault} />
+
+        <div className="grid grid-cols-1 xl:grid-cols-12 gap-6">
+          {/* 지도 영역 (50%) */}
+          <div className="xl:col-span-6">
+            <UnifiedMap
+              attractions={attractions}
+              onAddPlaceToItinerary={handleAddPlaceToItinerary}
+            />
+          </div>
+
+          {/* 일정 영역 (30%) */}
+          <div className="xl:col-span-4">
+            <div className="bg-white rounded-lg shadow-md">
+              <div className="p-4 border-b border-gray-200">
+                <h2 className="text-xl font-bold text-gray-800">
+                  🗓️ 여행 일정
+                </h2>
+              </div>
+              <Timeline
+                travelPlan={travelPlan}
+                setTravelPlan={setTravelPlan}
+              />
+            </div>
+          </div>
+
+          {/* 사이드바 (20%) */}
+          <div className="xl:col-span-2">
+            <TabNavigation
+              attractions={attractions}
+              travelPlan={travelPlan}
+              setTravelPlan={setTravelPlan}
+            />
+          </div>
+        </div>
+      </main>
+    </div>
+  )
+}
+
+export default PlanPage
\ No newline at end of file
diff --git a/src/pages/TripPage.tsx b/src/pages/TripPage.tsx
new file mode 100644
index 0000000..ec2f953
--- /dev/null
+++ b/src/pages/TripPage.tsx
@@ -0,0 +1,332 @@
+import { useState, useEffect } from 'react'
+import { useParams, useNavigate, Link } from 'react-router-dom'
+import { TravelPlan, Activity } from '../types'
+import { tripManagerService } from '../services/tripManager'
+import UnifiedMap from '../components/UnifiedMap'
+import { format, eachDayOfInterval } from 'date-fns'
+
+// 모바일용 여행 페이지 - 전체 화면 지도
+function TripPage() {
+  const { tripId } = useParams<{ tripId: string }>()
+  const navigate = useNavigate()
+  const [travelPlan, setTravelPlan] = useState<TravelPlan | null>(null)
+  const [isLoading, setIsLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [currentDay, setCurrentDay] = useState(0)
+  const [showSidebar, setShowSidebar] = useState(true)
+  const [selectedActivityId, setSelectedActivityId] = useState<string | null>(null)
+
+  // 여행 계획 로드
+  useEffect(() => {
+    async function loadTravelPlan() {
+      if (!tripId) {
+        setError('여행 ID가 제공되지 않았습니다')
+        setIsLoading(false)
+        return
+      }
+
+      try {
+        const plan = await tripManagerService.getTrip(tripId)
+        if (plan) {
+          setTravelPlan(plan)
+          
+          // 현재 날짜에 해당하는 일차 찾기
+          const today = new Date()
+          const days = eachDayOfInterval({
+            start: new Date(plan.startDate),
+            end: new Date(plan.endDate),
+          })
+          
+          const todayIndex = days.findIndex(day => 
+            format(day, 'yyyy-MM-dd') === format(today, 'yyyy-MM-dd')
+          )
+          
+          if (todayIndex !== -1) {
+            setCurrentDay(todayIndex)
+          }
+        } else {
+          setError('여행 계획을 찾을 수 없습니다')
+        }
+      } catch (err) {
+        console.error('Failed to load travel plan:', err)
+        setError('여행 계획을 불러오는 중 오류가 발생했습니다')
+      } finally {
+        setIsLoading(false)
+      }
+    }
+
+    loadTravelPlan()
+  }, [tripId])
+
+  // 날짜 변경시 선택 해제
+  useEffect(() => {
+    setSelectedActivityId(null)
+  }, [currentDay])
+
+  // 활동에서 좌표 가져오기
+  const getActivityCoords = (activity: Activity): [number, number] | null => {
+    if (activity.coordinates) {
+      return [activity.coordinates.lat, activity.coordinates.lng]
+    }
+    return null
+  }
+
+  // 활동 클릭 핸들러
+  const handleActivityClick = (activity: Activity) => {
+    setSelectedActivityId(activity.id)
+  }
+
+  if (isLoading) {
+    return (
+      <div className="min-h-screen bg-gray-100 flex items-center justify-center">
+        <div className="text-center">
+          <div className="animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600 mx-auto mb-4"></div>
+          <div className="text-lg text-gray-600">여행 계획을 불러오는 중...</div>
+        </div>
+      </div>
+    )
+  }
+
+  if (error || !travelPlan) {
+    return (
+      <div className="min-h-screen bg-gray-100 flex items-center justify-center">
+        <div className="text-center p-6">
+          <div className="text-4xl mb-4">⚠️</div>
+          <div className="text-lg font-medium text-gray-800 mb-2">
+            {error || '여행 계획을 찾을 수 없습니다'}
+          </div>
+          <div className="text-gray-600 mb-4">
+            다시 시도하거나 메인 페이지로 돌아가세요
+          </div>
+          <div className="flex gap-3 justify-center">
+            <button
+              onClick={() => window.location.reload()}
+              className="px-4 py-2 bg-blue-600 text-white rounded hover:bg-blue-700"
+            >
+              다시 시도
+            </button>
+            <Link
+              to="/"
+              className="px-4 py-2 bg-gray-600 text-white rounded hover:bg-gray-700"
+            >
+              메인으로 돌아가기
+            </Link>
+          </div>
+        </div>
+      </div>
+    )
+  }
+
+  const days = eachDayOfInterval({
+    start: new Date(travelPlan.startDate),
+    end: new Date(travelPlan.endDate),
+  })
+
+  const currentDaySchedule = travelPlan.schedule.find(
+    (daySchedule) =>
+      format(daySchedule.date, 'yyyy-MM-dd') === format(days[currentDay], 'yyyy-MM-dd')
+  )
+
+  const formatDate = (date: Date) => {
+    return format(date, 'M월 d일 (E)', { locale: undefined })
+  }
+
+  return (
+    <div className="h-screen flex flex-col bg-gray-100">
+      {/* 상단 헤더 */}
+      <div className="bg-white shadow-sm border-b border-gray-200 p-4 flex-shrink-0">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-3">
+            <Link
+              to="/"
+              className="text-gray-600 hover:text-gray-800"
+            >
+              ← 목록
+            </Link>
+            <div className="text-gray-300">|</div>
+            <h1 className="text-lg font-semibold text-gray-800">
+              {travelPlan.title}
+            </h1>
+          </div>
+          
+          <div className="flex items-center gap-2">
+            <Link
+              to={`/plan/${travelPlan.id}`}
+              className="px-3 py-1 bg-blue-600 text-white rounded text-sm hover:bg-blue-700"
+            >
+              ✏️ 편집
+            </Link>
+            <button
+              onClick={() => setShowSidebar(!showSidebar)}
+              className="px-3 py-1 bg-gray-600 text-white rounded text-sm hover:bg-gray-700 lg:hidden"
+            >
+              {showSidebar ? '지도만' : '일정'}
+            </button>
+          </div>
+        </div>
+
+        {/* 날짜 선택 탭 */}
+        <div className="flex gap-2 mt-3 overflow-x-auto pb-2">
+          {days.map((day, index) => (
+            <button
+              key={day.toISOString()}
+              onClick={() => setCurrentDay(index)}
+              className={`px-4 py-2 rounded-lg whitespace-nowrap text-sm transition-colors ${
+                currentDay === index
+                  ? 'bg-blue-600 text-white'
+                  : 'bg-gray-100 text-gray-700 hover:bg-gray-200'
+              }`}
+            >
+              <div className="font-medium">{formatDate(day)}</div>
+              <div className="text-xs opacity-75">
+                {index + 1}일차
+              </div>
+            </button>
+          ))}
+        </div>
+      </div>
+
+      {/* 메인 콘텐츠 */}
+      <div className="flex-1 flex relative">
+        {/* 지도 영역 */}
+        <div className={`flex-1 transition-all duration-300 ${showSidebar ? 'lg:mr-80' : ''}`}>
+          <UnifiedMap
+            attractions={[]}
+            selectedActivityId={selectedActivityId}
+            currentDaySchedule={currentDaySchedule}
+            onActivityClick={handleActivityClick}
+            getActivityCoords={getActivityCoords}
+            showControls={false}
+            className="h-full rounded-none shadow-none"
+          />
+        </div>
+
+        {/* 오른쪽 사이드바 (일정 정보) */}
+        {showSidebar && (
+          <div className="absolute right-0 top-0 bottom-0 w-80 bg-white shadow-lg border-l border-gray-200 overflow-y-auto lg:relative lg:w-80">
+            <div className="p-4">
+              <div className="flex items-center justify-between mb-4">
+                <h2 className="text-lg font-semibold text-gray-800">
+                  {formatDate(days[currentDay])} 일정
+                </h2>
+                <button
+                  onClick={() => setShowSidebar(false)}
+                  className="text-gray-400 hover:text-gray-600 lg:hidden"
+                >
+                  ×
+                </button>
+              </div>
+
+              {currentDaySchedule && currentDaySchedule.activities.length > 0 ? (
+                <div className="space-y-3">
+                  {currentDaySchedule.activities.map((activity) => (
+                    <div
+                      key={activity.id}
+                      onClick={() => handleActivityClick(activity)}
+                      className={`p-3 rounded-lg border cursor-pointer transition-colors ${
+                        selectedActivityId === activity.id
+                          ? 'border-blue-500 bg-blue-50'
+                          : 'border-gray-200 hover:border-gray-300 hover:bg-gray-50'
+                      }`}
+                    >
+                      <div className="flex items-start gap-3">
+                        <div className="text-sm font-medium text-blue-600 mt-0.5">
+                          {activity.time}
+                        </div>
+                        <div className="flex-1">
+                          <h3 className="font-medium text-gray-800 mb-1">
+                            {activity.title}
+                          </h3>
+                          {activity.location && (
+                            <div className="text-sm text-gray-600 mb-1">
+                              📍 {activity.location}
+                            </div>
+                          )}
+                          {activity.description && (
+                            <div className="text-sm text-gray-500">
+                              {activity.description}
+                            </div>
+                          )}
+                          <div className="mt-2">
+                            <span className={`inline-block px-2 py-1 text-xs rounded-full ${
+                              activity.type === 'attraction' ? 'bg-green-100 text-green-800' :
+                              activity.type === 'food' ? 'bg-orange-100 text-orange-800' :
+                              activity.type === 'accommodation' ? 'bg-purple-100 text-purple-800' :
+                              activity.type === 'transport' ? 'bg-blue-100 text-blue-800' :
+                              'bg-gray-100 text-gray-800'
+                            }`}>
+                              {activity.type === 'attraction' ? '관광' :
+                               activity.type === 'food' ? '식사' :
+                               activity.type === 'accommodation' ? '숙박' :
+                               activity.type === 'transport' ? '이동' : '기타'}
+                            </span>
+                          </div>
+                        </div>
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              ) : (
+                <div className="text-center py-8">
+                  <div className="text-4xl mb-3">📅</div>
+                  <div className="text-gray-600">
+                    이 날짜에 계획된 일정이 없습니다
+                  </div>
+                  <Link
+                    to={`/plan/${travelPlan.id}`}
+                    className="inline-block mt-3 px-4 py-2 bg-blue-600 text-white rounded text-sm hover:bg-blue-700"
+                  >
+                    일정 추가하기
+                  </Link>
+                </div>
+              )}
+
+              {/* 여행 정보 요약 */}
+              <div className="mt-6 pt-4 border-t border-gray-200">
+                <h3 className="font-medium text-gray-800 mb-3">여행 정보</h3>
+                <div className="space-y-2 text-sm">
+                  <div className="flex justify-between">
+                    <span className="text-gray-600">목적지</span>
+                    <span className="font-medium">
+                      {travelPlan.destination.city}, {travelPlan.destination.country}
+                    </span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span className="text-gray-600">기간</span>
+                    <span className="font-medium">
+                      {format(new Date(travelPlan.startDate), 'M/d')} - {format(new Date(travelPlan.endDate), 'M/d')}
+                    </span>
+                  </div>
+                  <div className="flex justify-between">
+                    <span className="text-gray-600">총 일정</span>
+                    <span className="font-medium">
+                      {travelPlan.schedule.reduce((total, day) => total + day.activities.length, 0)}개
+                    </span>
+                  </div>
+                </div>
+
+                {travelPlan.tags.length > 0 && (
+                  <div className="mt-3">
+                    <div className="text-sm text-gray-600 mb-2">태그</div>
+                    <div className="flex flex-wrap gap-1">
+                      {travelPlan.tags.map((tag) => (
+                        <span
+                          key={tag}
+                          className="inline-block px-2 py-1 bg-gray-100 text-gray-600 text-xs rounded"
+                        >
+                          #{tag}
+                        </span>
+                      ))}
+                    </div>
+                  </div>
+                )}
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  )
+}
+
+export default TripPage
\ No newline at end of file
diff --git a/src/services/api.ts b/src/services/api.ts
new file mode 100644
index 0000000..72116c4
--- /dev/null
+++ b/src/services/api.ts
@@ -0,0 +1,98 @@
+import { TravelPlan, BasePoint } from '../types'
+
+const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:3000'
+
+// 여행 계획 API
+export const travelPlanAPI = {
+  // 여행 계획 조회
+  async get(): Promise<TravelPlan | null> {
+    try {
+      const response = await fetch(`${API_URL}/api/travel-plans`)
+      if (!response.ok) throw new Error('Failed to fetch travel plan')
+      const data = await response.json()
+
+      if (!data) return null
+
+      // Date 객체로 변환
+      return {
+        ...data,
+        startDate: new Date(data.startDate),
+        endDate: new Date(data.endDate),
+        schedule: data.schedule.map((day: any) => ({
+          ...day,
+          date: new Date(day.date),
+        })),
+      }
+    } catch (error) {
+      console.error('Error fetching travel plan:', error)
+      // API 서버가 없으면 null 반환 (기본 데이터 사용)
+      return null
+    }
+  },
+
+  // 여행 계획 저장
+  async save(travelPlan: TravelPlan): Promise<void> {
+    try {
+      const response = await fetch(`${API_URL}/api/travel-plans`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(travelPlan),
+      })
+
+      if (!response.ok) throw new Error('Failed to save travel plan')
+    } catch (error) {
+      console.error('Error saving travel plan:', error)
+      // API 서버가 없으면 무시 (로컬 상태만 사용)
+    }
+  },
+}
+
+// 기본 포인트 API
+export const basePointsAPI = {
+  // 모든 기본 포인트 조회
+  async getAll(): Promise<BasePoint[]> {
+    try {
+      const response = await fetch(`${API_URL}/api/base-points`)
+      if (!response.ok) throw new Error('Failed to fetch base points')
+      return await response.json()
+    } catch (error) {
+      console.error('Error fetching base points:', error)
+      throw error
+    }
+  },
+
+  // 기본 포인트 추가
+  async create(basePoint: Omit<BasePoint, 'id'>): Promise<BasePoint> {
+    try {
+      const response = await fetch(`${API_URL}/api/base-points`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(basePoint),
+      })
+
+      if (!response.ok) throw new Error('Failed to create base point')
+      return await response.json()
+    } catch (error) {
+      console.error('Error creating base point:', error)
+      throw error
+    }
+  },
+
+  // 기본 포인트 삭제
+  async delete(id: string): Promise<void> {
+    try {
+      const response = await fetch(`${API_URL}/api/base-points/${id}`, {
+        method: 'DELETE',
+      })
+
+      if (!response.ok) throw new Error('Failed to delete base point')
+    } catch (error) {
+      console.error('Error deleting base point:', error)
+      throw error
+    }
+  },
+}
diff --git a/src/services/apiKeyManager.ts b/src/services/apiKeyManager.ts
new file mode 100644
index 0000000..08571d5
--- /dev/null
+++ b/src/services/apiKeyManager.ts
@@ -0,0 +1,171 @@
+/**
+ * Google Maps API 키 관리 서비스
+ */
+
+interface ApiKeyData {
+  googleMapsApiKey: string | null
+  lastUpdated: string
+  isValid: boolean
+}
+
+class ApiKeyManager {
+  private storageKey = 'google_maps_api_key_data'
+
+  /**
+   * API 키 데이터 가져오기
+   */
+  private getApiKeyData(): ApiKeyData {
+    const stored = localStorage.getItem(this.storageKey)
+    if (!stored) {
+      return {
+        googleMapsApiKey: null,
+        lastUpdated: '',
+        isValid: false
+      }
+    }
+
+    try {
+      return JSON.parse(stored)
+    } catch {
+      return {
+        googleMapsApiKey: null,
+        lastUpdated: '',
+        isValid: false
+      }
+    }
+  }
+
+  /**
+   * API 키 데이터 저장
+   */
+  private saveApiKeyData(data: ApiKeyData): void {
+    localStorage.setItem(this.storageKey, JSON.stringify(data))
+  }
+
+  /**
+   * Google Maps API 키 가져오기
+   * 우선순위: 로컬스토리지 > 환경변수
+   */
+  public getGoogleMapsApiKey(): string | null {
+    const data = this.getApiKeyData()
+    
+    // 로컬스토리지에 저장된 키가 있으면 사용
+    if (data.googleMapsApiKey) {
+      return data.googleMapsApiKey
+    }
+
+    // 환경변수에서 가져오기
+    return import.meta.env.VITE_GOOGLE_MAPS_API_KEY || null
+  }
+
+  /**
+   * Google Maps API 키 설정
+   */
+  public setGoogleMapsApiKey(apiKey: string): void {
+    const data: ApiKeyData = {
+      googleMapsApiKey: apiKey.trim(),
+      lastUpdated: new Date().toISOString(),
+      isValid: false // 유효성은 별도로 검증
+    }
+
+    this.saveApiKeyData(data)
+  }
+
+  /**
+   * API 키 삭제
+   */
+  public clearGoogleMapsApiKey(): void {
+    localStorage.removeItem(this.storageKey)
+  }
+
+  /**
+   * API 키 유효성 검증
+   */
+  public async validateGoogleMapsApiKey(apiKey?: string): Promise<{ isValid: boolean; error?: string }> {
+    const keyToValidate = apiKey || this.getGoogleMapsApiKey()
+    
+    if (!keyToValidate) {
+      return { isValid: false, error: 'API 키가 설정되지 않았습니다.' }
+    }
+
+    try {
+      // Google Maps JavaScript API 유효성 검증
+      // 간단한 Geocoding API 호출로 테스트
+      const response = await fetch(
+        `https://maps.googleapis.com/maps/api/geocode/json?address=Tokyo&key=${keyToValidate}`
+      )
+
+      if (!response.ok) {
+        return { isValid: false, error: `HTTP ${response.status}: ${response.statusText}` }
+      }
+
+      const data = await response.json()
+
+      if (data.status === 'OK') {
+        // 유효성 검증 성공 시 저장
+        if (apiKey) {
+          const apiKeyData = this.getApiKeyData()
+          apiKeyData.isValid = true
+          apiKeyData.lastUpdated = new Date().toISOString()
+          this.saveApiKeyData(apiKeyData)
+        }
+        return { isValid: true }
+      } else if (data.status === 'REQUEST_DENIED') {
+        return { isValid: false, error: 'API 키가 유효하지 않거나 권한이 없습니다.' }
+      } else if (data.status === 'OVER_QUERY_LIMIT') {
+        return { isValid: false, error: 'API 사용량 한도를 초과했습니다.' }
+      } else {
+        return { isValid: false, error: `API 오류: ${data.status}` }
+      }
+    } catch (error) {
+      return { 
+        isValid: false, 
+        error: `네트워크 오류: ${error instanceof Error ? error.message : '알 수 없는 오류'}` 
+      }
+    }
+  }
+
+  /**
+   * API 키 정보 가져오기
+   */
+  public getApiKeyInfo(): {
+    hasApiKey: boolean
+    isFromStorage: boolean
+    isFromEnv: boolean
+    lastUpdated: string
+    isValid: boolean
+  } {
+    const data = this.getApiKeyData()
+    const envKey = import.meta.env.VITE_GOOGLE_MAPS_API_KEY
+
+    return {
+      hasApiKey: !!(data.googleMapsApiKey || envKey),
+      isFromStorage: !!data.googleMapsApiKey,
+      isFromEnv: !!envKey,
+      lastUpdated: data.lastUpdated,
+      isValid: data.isValid
+    }
+  }
+
+  /**
+   * API 키 마스킹 (보안을 위해 일부만 표시)
+   */
+  public maskApiKey(apiKey?: string): string {
+    const key = apiKey || this.getGoogleMapsApiKey()
+    if (!key) return ''
+    
+    if (key.length <= 8) return key
+    return `${key.substring(0, 4)}...${key.substring(key.length - 4)}`
+  }
+}
+
+// 싱글톤 인스턴스
+export const apiKeyManager = new ApiKeyManager()
+
+// 편의 함수들
+export const getGoogleMapsApiKey = () => apiKeyManager.getGoogleMapsApiKey()
+export const setGoogleMapsApiKey = (key: string) => apiKeyManager.setGoogleMapsApiKey(key)
+export const validateGoogleMapsApiKey = (key?: string) => apiKeyManager.validateGoogleMapsApiKey(key)
+export const clearGoogleMapsApiKey = () => apiKeyManager.clearGoogleMapsApiKey()
+export const getApiKeyInfo = () => apiKeyManager.getApiKeyInfo()
+export const maskApiKey = (key?: string) => apiKeyManager.maskApiKey(key)
diff --git a/src/services/googleAuth.ts b/src/services/googleAuth.ts
new file mode 100644
index 0000000..0700e12
--- /dev/null
+++ b/src/services/googleAuth.ts
@@ -0,0 +1,319 @@
+// Google OAuth 및 사용자 데이터 서비스
+export interface GoogleUser {
+  id: string
+  email: string
+  name: string
+  picture: string
+  locale: string
+}
+
+export interface SavedPlace {
+  place_id: string
+  name: string
+  formatted_address: string
+  geometry: {
+    location: {
+      lat: number
+      lng: number
+    }
+  }
+  rating?: number
+  user_ratings_total?: number
+  types: string[]
+  photos?: google.maps.places.PlacePhoto[]
+  saved_lists: string[] // 어떤 리스트에 저장되었는지
+  user_rating?: number // 사용자가 준 평점
+  user_review?: string // 사용자 리뷰
+  visited?: boolean // 방문 여부
+}
+
+export interface GoogleMyMap {
+  id: string
+  title: string
+  description?: string
+  places: SavedPlace[]
+  created_date: string
+  updated_date: string
+}
+
+class GoogleAuthService {
+  private gapi: any = null
+  private auth2: any = null
+  private isInitialized = false
+
+  // Google API 초기화
+  async initialize(clientId: string) {
+    return new Promise<void>((resolve, reject) => {
+      if (typeof window === 'undefined') {
+        reject(new Error('Google Auth는 브라우저에서만 사용 가능합니다'))
+        return
+      }
+
+      // Google API 스크립트 로드
+      if (!window.gapi) {
+        const script = document.createElement('script')
+        script.src = 'https://apis.google.com/js/api.js'
+        script.onload = () => this.loadGapi(clientId, resolve, reject)
+        script.onerror = () => reject(new Error('Google API 스크립트 로드 실패'))
+        document.head.appendChild(script)
+      } else {
+        this.loadGapi(clientId, resolve, reject)
+      }
+    })
+  }
+
+  private loadGapi(clientId: string, resolve: () => void, reject: (error: Error) => void) {
+    window.gapi.load('auth2', () => {
+      window.gapi.auth2.init({
+        client_id: clientId,
+        scope: [
+          'profile',
+          'email',
+          'https://www.googleapis.com/auth/maps.readonly', // Google Maps 데이터 읽기
+          'https://www.googleapis.com/auth/mymaps.readonly' // My Maps 읽기
+        ].join(' ')
+      }).then(() => {
+        this.gapi = window.gapi
+        this.auth2 = window.gapi.auth2.getAuthInstance()
+        this.isInitialized = true
+        resolve()
+      }).catch((error: any) => {
+        reject(new Error(`Google Auth 초기화 실패: ${error.error || error}`))
+      })
+    })
+  }
+
+  // 로그인
+  async signIn(): Promise<GoogleUser> {
+    if (!this.isInitialized) {
+      throw new Error('Google Auth가 초기화되지 않았습니다')
+    }
+
+    try {
+      const authResult = await this.auth2.signIn()
+      const profile = authResult.getBasicProfile()
+      
+      const user: GoogleUser = {
+        id: profile.getId(),
+        email: profile.getEmail(),
+        name: profile.getName(),
+        picture: profile.getImageUrl(),
+        locale: profile.getLocale() || 'ko'
+      }
+
+      // 로컬 스토리지에 사용자 정보 저장
+      localStorage.setItem('google_user', JSON.stringify(user))
+      
+      return user
+    } catch (error) {
+      throw new Error(`로그인 실패: ${error}`)
+    }
+  }
+
+  // 로그아웃
+  async signOut(): Promise<void> {
+    if (!this.isInitialized) return
+
+    try {
+      await this.auth2.signOut()
+      localStorage.removeItem('google_user')
+    } catch (error) {
+      console.error('로그아웃 실패:', error)
+    }
+  }
+
+  // 현재 로그인된 사용자 정보
+  getCurrentUser(): GoogleUser | null {
+    const userStr = localStorage.getItem('google_user')
+    return userStr ? JSON.parse(userStr) : null
+  }
+
+  // 로그인 상태 확인
+  isSignedIn(): boolean {
+    return this.isInitialized && this.auth2?.isSignedIn.get() && this.getCurrentUser() !== null
+  }
+
+  // 저장된 장소 가져오기 (Google My Maps API 사용)
+  async getSavedPlaces(): Promise<SavedPlace[]> {
+    if (!this.isSignedIn()) {
+      throw new Error('로그인이 필요합니다')
+    }
+
+    try {
+      // Google My Maps API 호출
+      const response = await this.gapi.client.request({
+        path: 'https://www.googleapis.com/mymaps/v1/maps',
+        method: 'GET'
+      })
+
+      const savedPlaces: SavedPlace[] = []
+
+      // My Maps에서 장소 추출
+      if (response.result && response.result.maps) {
+        for (const map of response.result.maps) {
+          const mapPlaces = await this.getPlacesFromMap(map.id)
+          savedPlaces.push(...mapPlaces)
+        }
+      }
+
+      return savedPlaces
+    } catch (error) {
+      console.error('저장된 장소 가져오기 실패:', error)
+      // 폴백: 로컬 스토리지에서 이전에 저장된 데이터 사용
+      return this.getCachedSavedPlaces()
+    }
+  }
+
+  // 특정 My Map에서 장소들 가져오기
+  private async getPlacesFromMap(mapId: string): Promise<SavedPlace[]> {
+    try {
+      const response = await this.gapi.client.request({
+        path: `https://www.googleapis.com/mymaps/v1/maps/${mapId}/features`,
+        method: 'GET'
+      })
+
+      const places: SavedPlace[] = []
+
+      if (response.result && response.result.features) {
+        for (const feature of response.result.features) {
+          if (feature.geometry && feature.geometry.location) {
+            const place: SavedPlace = {
+              place_id: feature.properties?.place_id || `custom_${Date.now()}`,
+              name: feature.properties?.name || 'Unknown Place',
+              formatted_address: feature.properties?.address || '',
+              geometry: {
+                location: {
+                  lat: feature.geometry.location.latitude,
+                  lng: feature.geometry.location.longitude
+                }
+              },
+              types: feature.properties?.types || [],
+              saved_lists: [mapId],
+              user_rating: feature.properties?.rating,
+              user_review: feature.properties?.description
+            }
+            places.push(place)
+          }
+        }
+      }
+
+      return places
+    } catch (error) {
+      console.error(`Map ${mapId}에서 장소 가져오기 실패:`, error)
+      return []
+    }
+  }
+
+  // My Maps 목록 가져오기
+  async getMyMaps(): Promise<GoogleMyMap[]> {
+    if (!this.isSignedIn()) {
+      throw new Error('로그인이 필요합니다')
+    }
+
+    try {
+      const response = await this.gapi.client.request({
+        path: 'https://www.googleapis.com/mymaps/v1/maps',
+        method: 'GET'
+      })
+
+      const myMaps: GoogleMyMap[] = []
+
+      if (response.result && response.result.maps) {
+        for (const map of response.result.maps) {
+          const places = await this.getPlacesFromMap(map.id)
+          
+          const myMap: GoogleMyMap = {
+            id: map.id,
+            title: map.title || 'Untitled Map',
+            description: map.description,
+            places: places,
+            created_date: map.createTime,
+            updated_date: map.updateTime
+          }
+          
+          myMaps.push(myMap)
+        }
+      }
+
+      // 로컬 캐시에 저장
+      localStorage.setItem('google_my_maps', JSON.stringify(myMaps))
+      
+      return myMaps
+    } catch (error) {
+      console.error('My Maps 가져오기 실패:', error)
+      // 폴백: 캐시된 데이터 사용
+      return this.getCachedMyMaps()
+    }
+  }
+
+  // 캐시된 저장된 장소 가져오기
+  private getCachedSavedPlaces(): SavedPlace[] {
+    const cached = localStorage.getItem('google_saved_places')
+    return cached ? JSON.parse(cached) : []
+  }
+
+  // 캐시된 My Maps 가져오기
+  private getCachedMyMaps(): GoogleMyMap[] {
+    const cached = localStorage.getItem('google_my_maps')
+    return cached ? JSON.parse(cached) : []
+  }
+
+  // 저장된 장소를 일정에 추가하기 쉬운 형태로 변환
+  convertToItineraryFormat(savedPlace: SavedPlace) {
+    return {
+      id: `saved_${savedPlace.place_id}`,
+      title: savedPlace.name,
+      location: savedPlace.formatted_address,
+      description: savedPlace.user_review || `Google Maps에서 가져온 장소 (평점: ${savedPlace.user_rating || savedPlace.rating || 'N/A'})`,
+      type: this.inferActivityType(savedPlace.types),
+      coordinates: {
+        lat: savedPlace.geometry.location.lat,
+        lng: savedPlace.geometry.location.lng
+      },
+      time: '09:00', // 기본 시간
+      source: 'google_maps'
+    }
+  }
+
+  // 장소 타입에서 활동 타입 추론
+  private inferActivityType(types: string[]): 'attraction' | 'food' | 'accommodation' | 'transport' | 'other' {
+    if (types.includes('restaurant') || types.includes('food') || types.includes('meal_takeaway')) {
+      return 'food'
+    }
+    if (types.includes('lodging')) {
+      return 'accommodation'
+    }
+    if (types.includes('tourist_attraction') || types.includes('museum') || types.includes('park')) {
+      return 'attraction'
+    }
+    if (types.includes('transit_station') || types.includes('airport')) {
+      return 'transport'
+    }
+    return 'other'
+  }
+}
+
+// 싱글톤 인스턴스
+export const googleAuthService = new GoogleAuthService()
+
+// Google OAuth 설정
+export const GoogleAuthConfig = {
+  // 실제 사용시에는 환경변수로 관리
+  CLIENT_ID: import.meta.env.VITE_GOOGLE_OAUTH_CLIENT_ID || '',
+  
+  // 필요한 권한 범위
+  SCOPES: [
+    'profile',
+    'email',
+    'https://www.googleapis.com/auth/maps.readonly',
+    'https://www.googleapis.com/auth/mymaps.readonly'
+  ],
+  
+  // 지원하는 기능들
+  FEATURES: {
+    MY_MAPS: true,           // Google My Maps 지원
+    SAVED_PLACES: true,      // 저장된 장소 지원
+    REVIEWS: false,          // 리뷰 데이터 (제한적)
+    LOCATION_HISTORY: false  // 위치 기록 (프라이버시 이슈)
+  }
+} as const
diff --git a/src/services/googleDirections.ts b/src/services/googleDirections.ts
new file mode 100644
index 0000000..ad52791
--- /dev/null
+++ b/src/services/googleDirections.ts
@@ -0,0 +1,313 @@
+// Google Directions API 서비스
+export interface RouteWaypoint {
+  location: string | { lat: number; lng: number }
+  stopover?: boolean
+}
+
+export interface RouteOptions {
+  origin: string | { lat: number; lng: number }
+  destination: string | { lat: number; lng: number }
+  waypoints?: RouteWaypoint[]
+  travelMode?: google.maps.TravelMode
+  optimizeWaypoints?: boolean
+  avoidHighways?: boolean
+  avoidTolls?: boolean
+  region?: string
+}
+
+export interface RouteResult {
+  routes: google.maps.DirectionsRoute[]
+  optimizedOrder?: number[]
+  totalDistance: string
+  totalDuration: string
+  legs: {
+    distance: string
+    duration: string
+    startAddress: string
+    endAddress: string
+  }[]
+}
+
+export interface OptimizedItinerary {
+  originalActivities: any[]
+  optimizedActivities: any[]
+  routeResult: RouteResult
+  timeSaved: string
+  distanceSaved: string
+}
+
+class GoogleDirectionsService {
+  private directionsService: google.maps.DirectionsService | null = null
+  private directionsRenderer: google.maps.DirectionsRenderer | null = null
+
+  // Directions Service 초기화
+  initialize() {
+    if (typeof google !== 'undefined' && google.maps) {
+      this.directionsService = new google.maps.DirectionsService()
+      this.directionsRenderer = new google.maps.DirectionsRenderer({
+        suppressMarkers: false,
+        draggable: true
+      })
+    }
+  }
+
+  // 경로 계산
+  async calculateRoute(options: RouteOptions): Promise<RouteResult> {
+    if (!this.directionsService) {
+      throw new Error('Directions service not initialized')
+    }
+
+    return new Promise((resolve, reject) => {
+      const request: google.maps.DirectionsRequest = {
+        origin: options.origin,
+        destination: options.destination,
+        waypoints: options.waypoints || [],
+        travelMode: options.travelMode || google.maps.TravelMode.DRIVING,
+        optimizeWaypoints: options.optimizeWaypoints || false,
+        avoidHighways: options.avoidHighways || false,
+        avoidTolls: options.avoidTolls || false,
+        region: options.region || 'JP'
+      }
+
+      this.directionsService!.route(request, (result, status) => {
+        if (status === google.maps.DirectionsStatus.OK && result) {
+          const route = result.routes[0]
+          const legs = route.legs.map(leg => ({
+            distance: leg.distance?.text || '',
+            duration: leg.duration?.text || '',
+            startAddress: leg.start_address,
+            endAddress: leg.end_address
+          }))
+
+          // 총 거리와 시간 계산
+          const totalDistance = legs.reduce((total, leg) => {
+            const distance = parseFloat(leg.distance.replace(/[^\d.]/g, '')) || 0
+            return total + distance
+          }, 0)
+
+          const totalDuration = legs.reduce((total, leg) => {
+            const duration = this.parseDuration(leg.duration)
+            return total + duration
+          }, 0)
+
+          const routeResult: RouteResult = {
+            routes: result.routes,
+            optimizedOrder: result.routes[0].waypoint_order,
+            totalDistance: `${totalDistance.toFixed(1)} km`,
+            totalDuration: this.formatDuration(totalDuration),
+            legs
+          }
+
+          resolve(routeResult)
+        } else {
+          reject(new Error(`Directions request failed: ${status}`))
+        }
+      })
+    })
+  }
+
+  // 일정 최적화
+  async optimizeItinerary(activities: any[], travelMode: google.maps.TravelMode = google.maps.TravelMode.DRIVING): Promise<OptimizedItinerary> {
+    if (activities.length < 2) {
+      throw new Error('최소 2개 이상의 활동이 필요합니다')
+    }
+
+    // 좌표가 있는 활동만 필터링
+    const activitiesWithCoords = activities.filter(activity => 
+      activity.coordinates && activity.coordinates.lat && activity.coordinates.lng
+    )
+
+    if (activitiesWithCoords.length < 2) {
+      throw new Error('좌표 정보가 있는 활동이 최소 2개 필요합니다')
+    }
+
+    const origin = activitiesWithCoords[0].coordinates
+    const destination = activitiesWithCoords[activitiesWithCoords.length - 1].coordinates
+    const waypoints = activitiesWithCoords.slice(1, -1).map(activity => ({
+      location: activity.coordinates,
+      stopover: true
+    }))
+
+    try {
+      // 최적화된 경로 계산
+      const optimizedRoute = await this.calculateRoute({
+        origin,
+        destination,
+        waypoints,
+        travelMode,
+        optimizeWaypoints: true
+      })
+
+      // 최적화된 순서로 활동 재배열
+      const optimizedActivities = this.reorderActivities(activitiesWithCoords, optimizedRoute.optimizedOrder || [])
+
+      // 원래 경로와 비교를 위한 계산
+      const originalRoute = await this.calculateRoute({
+        origin,
+        destination,
+        waypoints,
+        travelMode,
+        optimizeWaypoints: false
+      })
+
+      const timeSaved = this.calculateTimeDifference(originalRoute.totalDuration, optimizedRoute.totalDuration)
+      const distanceSaved = this.calculateDistanceDifference(originalRoute.totalDistance, optimizedRoute.totalDistance)
+
+      return {
+        originalActivities: activitiesWithCoords,
+        optimizedActivities,
+        routeResult: optimizedRoute,
+        timeSaved,
+        distanceSaved
+      }
+    } catch (error) {
+      throw new Error(`경로 최적화 실패: ${error}`)
+    }
+  }
+
+  // 활동 재배열
+  private reorderActivities(activities: any[], waypointOrder: number[]): any[] {
+    if (!waypointOrder || waypointOrder.length === 0) {
+      return activities
+    }
+
+    const reordered = [activities[0]] // 시작점은 그대로
+
+    // 중간 지점들을 최적화된 순서로 배열
+    waypointOrder.forEach(index => {
+      if (activities[index + 1]) {
+        reordered.push(activities[index + 1])
+      }
+    })
+
+    // 마지막 지점 추가
+    if (activities.length > 1) {
+      reordered.push(activities[activities.length - 1])
+    }
+
+    return reordered
+  }
+
+  // 시간 파싱 (예: "1시간 30분" → 90분)
+  private parseDuration(durationText: string): number {
+    const hours = durationText.match(/(\d+)\s*시간/)?.[1] || '0'
+    const minutes = durationText.match(/(\d+)\s*분/)?.[1] || '0'
+    return parseInt(hours) * 60 + parseInt(minutes)
+  }
+
+  // 시간 포맷팅 (90분 → "1시간 30분")
+  private formatDuration(minutes: number): string {
+    const hours = Math.floor(minutes / 60)
+    const mins = minutes % 60
+    
+    if (hours > 0 && mins > 0) {
+      return `${hours}시간 ${mins}분`
+    } else if (hours > 0) {
+      return `${hours}시간`
+    } else {
+      return `${mins}분`
+    }
+  }
+
+  // 시간 차이 계산
+  private calculateTimeDifference(original: string, optimized: string): string {
+    const originalMinutes = this.parseDuration(original)
+    const optimizedMinutes = this.parseDuration(optimized)
+    const difference = originalMinutes - optimizedMinutes
+    
+    if (difference > 0) {
+      return `${this.formatDuration(difference)} 단축`
+    } else if (difference < 0) {
+      return `${this.formatDuration(Math.abs(difference))} 증가`
+    } else {
+      return '변화 없음'
+    }
+  }
+
+  // 거리 차이 계산
+  private calculateDistanceDifference(original: string, optimized: string): string {
+    const originalKm = parseFloat(original.replace(/[^\d.]/g, '')) || 0
+    const optimizedKm = parseFloat(optimized.replace(/[^\d.]/g, '')) || 0
+    const difference = originalKm - optimizedKm
+    
+    if (difference > 0) {
+      return `${difference.toFixed(1)}km 단축`
+    } else if (difference < 0) {
+      return `${Math.abs(difference).toFixed(1)}km 증가`
+    } else {
+      return '변화 없음'
+    }
+  }
+
+  // 지도에 경로 표시
+  displayRoute(map: google.maps.Map, routeResult: RouteResult) {
+    if (!this.directionsRenderer) {
+      this.directionsRenderer = new google.maps.DirectionsRenderer({
+        suppressMarkers: false,
+        draggable: false
+      })
+    }
+
+    this.directionsRenderer.setMap(map)
+    this.directionsRenderer.setDirections({
+      routes: routeResult.routes,
+      request: {} as google.maps.DirectionsRequest
+    } as google.maps.DirectionsResult)
+  }
+
+  // 경로 숨기기
+  hideRoute() {
+    if (this.directionsRenderer) {
+      this.directionsRenderer.setMap(null)
+    }
+  }
+}
+
+// 싱글톤 인스턴스
+export const googleDirectionsService = new GoogleDirectionsService()
+
+// 여행 모드 옵션
+export const TravelModeOptions = {
+  DRIVING: {
+    mode: 'DRIVING',
+    label: '🚗 자동차',
+    description: '렌터카 또는 자가용'
+  },
+  TRANSIT: {
+    mode: 'TRANSIT',
+    label: '🚌 대중교통',
+    description: '버스, 지하철, 기차'
+  },
+  WALKING: {
+    mode: 'WALKING',
+    label: '🚶 도보',
+    description: '걸어서 이동'
+  }
+} as const
+
+// 구마모토 특화 경로 옵션
+export const KumamotoRoutePresets = {
+  // 시내 관광 (도보 중심)
+  cityTour: {
+    travelMode: 'WALKING',
+    avoidHighways: true,
+    avoidTolls: true,
+    description: '구마모토 시내 도보 관광'
+  },
+  
+  // 렌터카 여행
+  carTour: {
+    travelMode: 'DRIVING',
+    avoidTolls: false,
+    avoidHighways: false,
+    description: '렌터카로 구마모토 전역 여행'
+  },
+  
+  // 대중교통 이용
+  publicTransport: {
+    travelMode: 'TRANSIT',
+    avoidHighways: true,
+    avoidTolls: true,
+    description: '버스/전차로 구마모토 여행'
+  }
+} as const
diff --git a/src/services/googleMapsUsage.ts b/src/services/googleMapsUsage.ts
new file mode 100644
index 0000000..70e5cb6
--- /dev/null
+++ b/src/services/googleMapsUsage.ts
@@ -0,0 +1,257 @@
+/**
+ * Google Maps API 사용량 추적 및 제한 서비스
+ * 
+ * Google Maps JavaScript API 무료 한도:
+ * - Maps JavaScript API: 월 28,000 요청
+ * - 일일 약 933 요청 (28,000 / 30일)
+ * - 시간당 약 39 요청 (933 / 24시간)
+ */
+
+interface UsageData {
+  daily: number
+  monthly: number
+  lastReset: string
+  dailyLimit: number
+  monthlyLimit: number
+}
+
+class GoogleMapsUsageTracker {
+  private storageKey = 'google_maps_usage'
+  
+  // 무료 한도 설정 (안전 마진 20% 적용)
+  private readonly DAILY_LIMIT = 750  // 933의 80%
+  private readonly MONTHLY_LIMIT = 22400  // 28,000의 80%
+  private readonly HOURLY_LIMIT = 30  // 39의 80%
+  
+  private hourlyUsage: { [hour: string]: number } = {}
+
+  constructor() {
+    this.initializeUsage()
+    this.setupDailyReset()
+  }
+
+  /**
+   * 사용량 데이터 초기화
+   */
+  private initializeUsage(): void {
+    const stored = localStorage.getItem(this.storageKey)
+    if (!stored) {
+      this.resetUsage()
+    }
+  }
+
+  /**
+   * 현재 사용량 데이터 가져오기
+   */
+  private getUsageData(): UsageData {
+    const stored = localStorage.getItem(this.storageKey)
+    if (!stored) {
+      return this.getDefaultUsageData()
+    }
+
+    try {
+      return JSON.parse(stored)
+    } catch {
+      return this.getDefaultUsageData()
+    }
+  }
+
+  /**
+   * 기본 사용량 데이터
+   */
+  private getDefaultUsageData(): UsageData {
+    return {
+      daily: 0,
+      monthly: 0,
+      lastReset: new Date().toISOString().split('T')[0], // YYYY-MM-DD
+      dailyLimit: this.DAILY_LIMIT,
+      monthlyLimit: this.MONTHLY_LIMIT
+    }
+  }
+
+  /**
+   * 사용량 데이터 저장
+   */
+  private saveUsageData(data: UsageData): void {
+    localStorage.setItem(this.storageKey, JSON.stringify(data))
+  }
+
+  /**
+   * 사용량 초기화
+   */
+  private resetUsage(): void {
+    const defaultData = this.getDefaultUsageData()
+    this.saveUsageData(defaultData)
+  }
+
+  /**
+   * 일일 리셋 체크 및 실행
+   */
+  private setupDailyReset(): void {
+    const data = this.getUsageData()
+    const today = new Date().toISOString().split('T')[0]
+    
+    if (data.lastReset !== today) {
+      // 새로운 날이면 일일 사용량 리셋
+      data.daily = 0
+      data.lastReset = today
+      
+      // 새로운 달이면 월간 사용량도 리셋
+      const lastResetMonth = new Date(data.lastReset).getMonth()
+      const currentMonth = new Date().getMonth()
+      
+      if (lastResetMonth !== currentMonth) {
+        data.monthly = 0
+      }
+      
+      this.saveUsageData(data)
+    }
+  }
+
+  /**
+   * 시간당 사용량 체크
+   */
+  private checkHourlyLimit(): boolean {
+    const currentHour = new Date().toISOString().slice(0, 13) // YYYY-MM-DDTHH
+    const hourlyCount = this.hourlyUsage[currentHour] || 0
+    
+    return hourlyCount < this.HOURLY_LIMIT
+  }
+
+  /**
+   * 시간당 사용량 증가
+   */
+  private incrementHourlyUsage(): void {
+    const currentHour = new Date().toISOString().slice(0, 13)
+    this.hourlyUsage[currentHour] = (this.hourlyUsage[currentHour] || 0) + 1
+    
+    // 오래된 시간 데이터 정리 (24시간 이전)
+    const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString().slice(0, 13)
+    Object.keys(this.hourlyUsage).forEach(hour => {
+      if (hour < cutoff) {
+        delete this.hourlyUsage[hour]
+      }
+    })
+  }
+
+  /**
+   * API 사용 가능 여부 체크
+   */
+  public canUseAPI(): { allowed: boolean; reason?: string; usage?: any } {
+    this.setupDailyReset()
+    
+    const data = this.getUsageData()
+    const usage = {
+      daily: { current: data.daily, limit: data.dailyLimit },
+      monthly: { current: data.monthly, limit: data.monthlyLimit },
+      hourly: { 
+        current: this.hourlyUsage[new Date().toISOString().slice(0, 13)] || 0, 
+        limit: this.HOURLY_LIMIT 
+      }
+    }
+
+    // 월간 한도 체크
+    if (data.monthly >= data.monthlyLimit) {
+      return {
+        allowed: false,
+        reason: `월간 사용량 한도 초과 (${data.monthly}/${data.monthlyLimit})`,
+        usage
+      }
+    }
+
+    // 일일 한도 체크
+    if (data.daily >= data.dailyLimit) {
+      return {
+        allowed: false,
+        reason: `일일 사용량 한도 초과 (${data.daily}/${data.dailyLimit})`,
+        usage
+      }
+    }
+
+    // 시간당 한도 체크
+    if (!this.checkHourlyLimit()) {
+      return {
+        allowed: false,
+        reason: `시간당 사용량 한도 초과 (${usage.hourly.current}/${this.HOURLY_LIMIT})`,
+        usage
+      }
+    }
+
+    return { allowed: true, usage }
+  }
+
+  /**
+   * API 사용량 증가
+   */
+  public incrementUsage(): void {
+    const data = this.getUsageData()
+    data.daily += 1
+    data.monthly += 1
+    this.saveUsageData(data)
+    this.incrementHourlyUsage()
+  }
+
+  /**
+   * 현재 사용량 정보 가져오기
+   */
+  public getUsageInfo(): any {
+    this.setupDailyReset()
+    const data = this.getUsageData()
+    
+    return {
+      daily: {
+        current: data.daily,
+        limit: data.dailyLimit,
+        percentage: Math.round((data.daily / data.dailyLimit) * 100)
+      },
+      monthly: {
+        current: data.monthly,
+        limit: data.monthlyLimit,
+        percentage: Math.round((data.monthly / data.monthlyLimit) * 100)
+      },
+      hourly: {
+        current: this.hourlyUsage[new Date().toISOString().slice(0, 13)] || 0,
+        limit: this.HOURLY_LIMIT,
+        percentage: Math.round(((this.hourlyUsage[new Date().toISOString().slice(0, 13)] || 0) / this.HOURLY_LIMIT) * 100)
+      },
+      lastReset: data.lastReset
+    }
+  }
+
+  /**
+   * 사용량 리셋 (관리자용)
+   */
+  public resetUsageData(): void {
+    this.resetUsage()
+    this.hourlyUsage = {}
+  }
+
+  /**
+   * 경고 레벨 체크
+   */
+  public getWarningLevel(): 'safe' | 'warning' | 'danger' | 'blocked' {
+    const { allowed, usage } = this.canUseAPI()
+    
+    if (!allowed) return 'blocked'
+    
+    const maxPercentage = Math.max(
+      usage.daily.current / usage.daily.limit,
+      usage.monthly.current / usage.monthly.limit,
+      usage.hourly.current / usage.hourly.limit
+    ) * 100
+
+    if (maxPercentage >= 90) return 'danger'
+    if (maxPercentage >= 70) return 'warning'
+    return 'safe'
+  }
+}
+
+// 싱글톤 인스턴스
+export const googleMapsUsage = new GoogleMapsUsageTracker()
+
+// 편의 함수들
+export const canUseGoogleMaps = () => googleMapsUsage.canUseAPI()
+export const incrementGoogleMapsUsage = () => googleMapsUsage.incrementUsage()
+export const getGoogleMapsUsage = () => googleMapsUsage.getUsageInfo()
+export const getGoogleMapsWarningLevel = () => googleMapsUsage.getWarningLevel()
+export const resetGoogleMapsUsage = () => googleMapsUsage.resetUsageData()
diff --git a/src/services/googlePlaces.ts b/src/services/googlePlaces.ts
new file mode 100644
index 0000000..b3cc22d
--- /dev/null
+++ b/src/services/googlePlaces.ts
@@ -0,0 +1,267 @@
+// Google Places API 서비스
+export interface PlaceResult {
+  place_id: string
+  name: string
+  formatted_address: string
+  geometry: {
+    location: {
+      lat: number
+      lng: number
+    }
+  }
+  rating?: number
+  price_level?: number
+  types: string[]
+  photos?: google.maps.places.PlacePhoto[]
+  opening_hours?: {
+    open_now: boolean
+    weekday_text: string[]
+  }
+  website?: string
+  formatted_phone_number?: string
+  reviews?: google.maps.places.PlaceReview[]
+}
+
+export interface PlaceSearchOptions {
+  query: string
+  location?: { lat: number; lng: number }
+  radius?: number
+  type?: string[]
+  minRating?: number
+  maxPriceLevel?: number
+}
+
+class GooglePlacesService {
+  private placesService: google.maps.places.PlacesService | null = null
+  private map: google.maps.Map | null = null
+
+  // Places Service 초기화
+  initialize(map: google.maps.Map) {
+    this.map = map
+    this.placesService = new google.maps.places.PlacesService(map)
+  }
+
+  // 텍스트 검색 (일반 검색)
+  async textSearch(options: PlaceSearchOptions): Promise<PlaceResult[]> {
+    if (!this.placesService) {
+      throw new Error('Places service not initialized')
+    }
+
+    return new Promise((resolve, reject) => {
+      const request: google.maps.places.TextSearchRequest = {
+        query: options.query,
+        location: options.location ? 
+          new google.maps.LatLng(options.location.lat, options.location.lng) : 
+          undefined,
+        radius: options.radius || 5000,
+        type: options.type?.[0] as any
+      }
+
+      this.placesService!.textSearch(request, (results, status) => {
+        if (status === google.maps.places.PlacesServiceStatus.OK && results) {
+          const filteredResults = results
+            .filter(place => {
+              if (options.minRating && (!place.rating || place.rating < options.minRating)) {
+                return false
+              }
+              if (options.maxPriceLevel && place.price_level && place.price_level > options.maxPriceLevel) {
+                return false
+              }
+              return true
+            })
+            .map(place => ({
+              place_id: place.place_id!,
+              name: place.name!,
+              formatted_address: place.formatted_address!,
+              geometry: {
+                location: {
+                  lat: place.geometry!.location!.lat(),
+                  lng: place.geometry!.location!.lng()
+                }
+              },
+              rating: place.rating,
+              price_level: place.price_level,
+              types: place.types || [],
+              photos: place.photos,
+              opening_hours: place.opening_hours
+            }))
+
+          resolve(filteredResults)
+        } else {
+          reject(new Error(`Places search failed: ${status}`))
+        }
+      })
+    })
+  }
+
+  // 주변 검색 (Nearby Search)
+  async nearbySearch(options: PlaceSearchOptions): Promise<PlaceResult[]> {
+    if (!this.placesService || !options.location) {
+      throw new Error('Places service not initialized or location not provided')
+    }
+
+    return new Promise((resolve, reject) => {
+      const request: google.maps.places.PlaceSearchRequest = {
+        location: new google.maps.LatLng(options.location!.lat, options.location!.lng),
+        radius: options.radius || 1000,
+        type: options.type?.[0] as any,
+        keyword: options.query
+      }
+
+      this.placesService!.nearbySearch(request, (results, status) => {
+        if (status === google.maps.places.PlacesServiceStatus.OK && results) {
+          const filteredResults = results
+            .filter(place => {
+              if (options.minRating && (!place.rating || place.rating < options.minRating)) {
+                return false
+              }
+              if (options.maxPriceLevel && place.price_level && place.price_level > options.maxPriceLevel) {
+                return false
+              }
+              return true
+            })
+            .map(place => ({
+              place_id: place.place_id!,
+              name: place.name!,
+              formatted_address: place.formatted_address || place.vicinity || '',
+              geometry: {
+                location: {
+                  lat: place.geometry!.location!.lat(),
+                  lng: place.geometry!.location!.lng()
+                }
+              },
+              rating: place.rating,
+              price_level: place.price_level,
+              types: place.types || [],
+              photos: place.photos,
+              opening_hours: place.opening_hours
+            }))
+
+          resolve(filteredResults)
+        } else {
+          reject(new Error(`Nearby search failed: ${status}`))
+        }
+      })
+    })
+  }
+
+  // 장소 상세 정보 가져오기
+  async getPlaceDetails(placeId: string): Promise<PlaceResult | null> {
+    if (!this.placesService) {
+      throw new Error('Places service not initialized')
+    }
+
+    return new Promise((resolve, reject) => {
+      const request: google.maps.places.PlaceDetailsRequest = {
+        placeId: placeId,
+        fields: [
+          'place_id', 'name', 'formatted_address', 'geometry',
+          'rating', 'price_level', 'types', 'photos',
+          'opening_hours', 'website', 'formatted_phone_number', 'reviews'
+        ]
+      }
+
+      this.placesService!.getDetails(request, (place, status) => {
+        if (status === google.maps.places.PlacesServiceStatus.OK && place) {
+          const result: PlaceResult = {
+            place_id: place.place_id!,
+            name: place.name!,
+            formatted_address: place.formatted_address!,
+            geometry: {
+              location: {
+                lat: place.geometry!.location!.lat(),
+                lng: place.geometry!.location!.lng()
+              }
+            },
+            rating: place.rating,
+            price_level: place.price_level,
+            types: place.types || [],
+            photos: place.photos,
+            opening_hours: place.opening_hours,
+            website: place.website,
+            formatted_phone_number: place.formatted_phone_number,
+            reviews: place.reviews
+          }
+          resolve(result)
+        } else {
+          reject(new Error(`Place details failed: ${status}`))
+        }
+      })
+    })
+  }
+
+  // 자동완성 검색
+  async getAutocompletePredictions(input: string, location?: { lat: number; lng: number }): Promise<google.maps.places.AutocompletePrediction[]> {
+    return new Promise((resolve, reject) => {
+      const service = new google.maps.places.AutocompleteService()
+      
+      const request: google.maps.places.AutocompletionRequest = {
+        input: input,
+        location: location ? 
+          new google.maps.LatLng(location.lat, location.lng) : 
+          undefined,
+        radius: 10000,
+        componentRestrictions: { country: 'jp' }, // 일본으로 제한
+        types: ['establishment'] // 사업체만
+      }
+
+      service.getPlacePredictions(request, (predictions, status) => {
+        if (status === google.maps.places.PlacesServiceStatus.OK && predictions) {
+          resolve(predictions)
+        } else {
+          resolve([])
+        }
+      })
+    })
+  }
+}
+
+// 싱글톤 인스턴스
+export const googlePlacesService = new GooglePlacesService()
+
+// 구마모토 특화 검색 프리셋
+export const KumamotoSearchPresets = {
+  // 관광지
+  attractions: {
+    query: "구마모토 관광지",
+    type: ["tourist_attraction"],
+    minRating: 3.5
+  },
+  
+  // 맛집
+  restaurants: {
+    query: "구마모토 맛집",
+    type: ["restaurant"],
+    minRating: 4.0,
+    maxPriceLevel: 3
+  },
+  
+  // 라멘집
+  ramen: {
+    query: "구마모토 라멘",
+    type: ["restaurant"],
+    minRating: 4.0,
+    maxPriceLevel: 2
+  },
+  
+  // 온천
+  onsen: {
+    query: "구마모토 온천",
+    type: ["spa"],
+    minRating: 4.0
+  },
+  
+  // 쇼핑
+  shopping: {
+    query: "구마모토 쇼핑",
+    type: ["shopping_mall", "store"],
+    minRating: 3.5
+  },
+  
+  // 숙박
+  accommodation: {
+    query: "구마모토 호텔",
+    type: ["lodging"],
+    minRating: 3.5
+  }
+}
diff --git a/src/services/initialSetup.ts b/src/services/initialSetup.ts
new file mode 100644
index 0000000..6cfd532
--- /dev/null
+++ b/src/services/initialSetup.ts
@@ -0,0 +1,304 @@
+// 서버 초기 설정 및 관리자 계정 생성 서비스
+export interface InitialSetupData {
+  admin_name: string
+  admin_email: string
+  admin_password: string
+  site_name: string
+  site_description?: string
+  default_language: 'ko' | 'en' | 'ja'
+  default_currency: 'KRW' | 'JPY' | 'USD'
+}
+
+export interface SetupStatus {
+  is_setup_required: boolean
+  setup_step: 'initial' | 'admin_account' | 'site_config' | 'complete'
+  has_admin: boolean
+  total_users: number
+  version: string
+}
+
+import { apiUrl } from '../utils/env'
+
+class InitialSetupService {
+  private readonly API_BASE = `${apiUrl}/api/setup`
+  private readonly SETUP_KEY = 'travel_planner_setup_status'
+
+  // 초기 설정 필요 여부 확인
+  async checkSetupStatus(): Promise<SetupStatus> {
+    // 개발 환경에서는 바로 로컬 스토리지 사용 (API 호출 건너뛰기)
+    if (import.meta.env.DEV) {
+      return this.getLocalSetupStatus()
+    }
+
+    try {
+      const response = await fetch(`${this.API_BASE}/status`)
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`)
+      }
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Setup status check failed:', error)
+      
+      // 서버 연결 실패시 초기 설정 필요로 간주
+      return {
+        is_setup_required: true,
+        setup_step: 'initial',
+        has_admin: false,
+        total_users: 0,
+        version: '1.0.0'
+      }
+    }
+  }
+
+  // 초기 설정 실행
+  async performInitialSetup(setupData: InitialSetupData): Promise<{ success: boolean; message: string }> {
+    try {
+      const response = await fetch(`${this.API_BASE}/initialize`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(setupData)
+      })
+
+      const result = await response.json()
+      
+      if (result.success) {
+        // 설정 완료 상태 저장
+        this.markSetupComplete()
+      }
+      
+      return result
+    } catch (error) {
+      console.error('Initial setup failed:', error)
+      
+      // 개발 환경에서는 로컬 설정
+      if (import.meta.env.DEV) {
+        return this.performLocalSetup(setupData)
+      }
+      
+      return {
+        success: false,
+        message: '초기 설정 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 데이터베이스 연결 테스트
+  async testDatabaseConnection(): Promise<{ success: boolean; message: string }> {
+    try {
+      const response = await fetch(`${this.API_BASE}/test-db`)
+      const result = await response.json()
+      return result
+    } catch (error) {
+      return {
+        success: false,
+        message: '데이터베이스 연결을 확인할 수 없습니다'
+      }
+    }
+  }
+
+  // 환경 변수 확인
+  async checkEnvironment(): Promise<{
+    database_url: boolean
+    jwt_secret: boolean
+    google_maps_key: boolean
+    email_config: boolean
+  }> {
+    try {
+      const response = await fetch(`${this.API_BASE}/check-env`)
+      const result = await response.json()
+      return result
+    } catch (error) {
+      return {
+        database_url: false,
+        jwt_secret: false,
+        google_maps_key: false,
+        email_config: false
+      }
+    }
+  }
+
+  // 설정 완료 표시
+  private markSetupComplete(): void {
+    const setupStatus = {
+      is_complete: true,
+      completed_at: new Date().toISOString(),
+      version: '1.0.0'
+    }
+    localStorage.setItem(this.SETUP_KEY, JSON.stringify(setupStatus))
+  }
+
+  // 로컬 설정 상태 확인 (개발용)
+  private getLocalSetupStatus(): SetupStatus {
+    const users = this.getStoredUsers()
+    const hasAdmin = users.some(u => u.role === 'admin')
+
+    try {
+      const setupStatus = localStorage.getItem(this.SETUP_KEY)
+
+      if (setupStatus) {
+        const status = JSON.parse(setupStatus)
+        if (status.is_complete) {
+          return {
+            is_setup_required: false,
+            setup_step: 'complete',
+            has_admin: hasAdmin,
+            total_users: users.length,
+            version: status.version || '2.0.0'
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Failed to parse setup status:', error)
+      // 파싱 에러 시 로컬 스토리지 초기화
+      localStorage.removeItem(this.SETUP_KEY)
+    }
+
+    return {
+      is_setup_required: !hasAdmin,
+      setup_step: hasAdmin ? 'complete' : 'initial',
+      has_admin: hasAdmin,
+      total_users: users.length,
+      version: '2.0.0'
+    }
+  }
+
+  // 로컬 초기 설정 (개발용)
+  private performLocalSetup(setupData: InitialSetupData): { success: boolean; message: string } {
+    try {
+      const users = this.getStoredUsers()
+      
+      // 이미 관리자가 있는지 확인
+      if (users.some(u => u.role === 'admin')) {
+        return {
+          success: false,
+          message: '이미 관리자 계정이 존재합니다'
+        }
+      }
+
+      // 관리자 계정 생성
+      const adminUser = {
+        id: `admin_${Date.now()}`,
+        email: setupData.admin_email,
+        name: setupData.admin_name,
+        role: 'admin' as const,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        is_active: true,
+        preferences: {
+          default_currency: setupData.default_currency,
+          language: setupData.default_language,
+          theme: 'light' as const,
+          map_provider: 'google' as const
+        }
+      }
+
+      // 사용자 목록에 추가
+      users.push(adminUser)
+      localStorage.setItem('dev_users', JSON.stringify(users))
+
+      // 비밀번호 저장
+      const passwords = this.getStoredPasswords()
+      passwords[setupData.admin_email] = setupData.admin_password
+      localStorage.setItem('dev_passwords', JSON.stringify(passwords))
+
+      // 사이트 설정 저장
+      const siteConfig = {
+        site_name: setupData.site_name,
+        site_description: setupData.site_description,
+        default_language: setupData.default_language,
+        default_currency: setupData.default_currency,
+        setup_completed_at: new Date().toISOString()
+      }
+      localStorage.setItem('site_config', JSON.stringify(siteConfig))
+
+      // 설정 완료 표시
+      this.markSetupComplete()
+
+      return {
+        success: true,
+        message: '초기 설정이 완료되었습니다'
+      }
+    } catch (error) {
+      console.error('Local setup failed:', error)
+      return {
+        success: false,
+        message: '로컬 설정 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 사이트 설정 가져오기
+  getSiteConfig() {
+    try {
+      const config = localStorage.getItem('site_config')
+      return config ? JSON.parse(config) : {
+        site_name: 'Travel Planner',
+        site_description: '스마트한 여행 계획 도구',
+        default_language: 'ko',
+        default_currency: 'KRW'
+      }
+    } catch {
+      return {
+        site_name: 'Travel Planner',
+        site_description: '스마트한 여행 계획 도구',
+        default_language: 'ko',
+        default_currency: 'KRW'
+      }
+    }
+  }
+
+  // 설정 초기화 (개발용)
+  resetSetup(): void {
+    localStorage.removeItem(this.SETUP_KEY)
+    localStorage.removeItem('site_config')
+    localStorage.removeItem('dev_users')
+    localStorage.removeItem('dev_passwords')
+    console.log('설정이 초기화되었습니다')
+  }
+
+  // 개발용 헬퍼 메서드들
+  private getStoredUsers() {
+    try {
+      const stored = localStorage.getItem('dev_users')
+      return stored ? JSON.parse(stored) : []
+    } catch {
+      return []
+    }
+  }
+
+  private getStoredPasswords() {
+    try {
+      const stored = localStorage.getItem('dev_passwords')
+      return stored ? JSON.parse(stored) : {}
+    } catch {
+      return {}
+    }
+  }
+}
+
+// 싱글톤 인스턴스
+export const initialSetupService = new InitialSetupService()
+
+// 설정 상태 확인 유틸리티
+export const SetupUtils = {
+  // 초기 설정이 필요한지 확인
+  async isSetupRequired(): Promise<boolean> {
+    const status = await initialSetupService.checkSetupStatus()
+    return status.is_setup_required
+  },
+
+  // 관리자 계정 존재 여부 확인
+  async hasAdminAccount(): Promise<boolean> {
+    const status = await initialSetupService.checkSetupStatus()
+    return status.has_admin
+  },
+
+  // 설정 단계 확인
+  async getCurrentSetupStep(): Promise<string> {
+    const status = await initialSetupService.checkSetupStatus()
+    return status.setup_step
+  }
+} as const
diff --git a/src/services/offlineSupport.ts b/src/services/offlineSupport.ts
new file mode 100644
index 0000000..f903574
--- /dev/null
+++ b/src/services/offlineSupport.ts
@@ -0,0 +1,381 @@
+// 오프라인 지원 및 데이터 캐싱 서비스
+import { TravelPlan, Activity } from '../types'
+
+export interface CachedActivityData {
+  id: string
+  title: string
+  location: string
+  coordinates?: {
+    lat: number
+    lng: number
+  }
+  description?: string
+  time: string
+  type: Activity['type']
+  cached_at: string
+  source: 'google_places' | 'google_maps' | 'manual' | 'imported'
+  offline_data: {
+    // 오프라인에서도 표시할 수 있는 기본 정보
+    address: string
+    category: string
+    estimated_duration?: string
+    notes?: string
+    // 이미지는 base64로 저장 (작은 썸네일만)
+    thumbnail?: string
+  }
+}
+
+export interface OfflineMapData {
+  // 오프라인 지도용 기본 데이터
+  center: { lat: number; lng: number }
+  zoom: number
+  activities: CachedActivityData[]
+  routes?: {
+    // 미리 계산된 경로 정보
+    day: string
+    waypoints: { lat: number; lng: number; name: string }[]
+    distance: string
+    duration: string
+    instructions: string[]
+  }[]
+  cached_at: string
+}
+
+class OfflineSupportService {
+  private readonly CACHE_KEY = 'kumamoto_offline_data'
+  private readonly ACTIVITY_CACHE_KEY = 'kumamoto_cached_activities'
+  private readonly MAX_CACHE_AGE = 7 * 24 * 60 * 60 * 1000 // 7일
+
+  // 여행 계획을 오프라인용으로 캐시
+  async cacheTravelPlan(travelPlan: TravelPlan): Promise<void> {
+    try {
+      const offlineData: OfflineMapData = {
+        center: { lat: 32.7898, lng: 130.7417 }, // 구마모토 중심
+        zoom: 11,
+        activities: [],
+        routes: [],
+        cached_at: new Date().toISOString()
+      }
+
+      // 모든 활동을 오프라인 데이터로 변환
+      for (const daySchedule of travelPlan.schedule) {
+        for (const activity of daySchedule.activities) {
+          const cachedActivity = await this.cacheActivity(activity)
+          offlineData.activities.push(cachedActivity)
+        }
+
+        // 하루 경로 정보도 캐시 (Google Directions API 결과가 있다면)
+        const routeData = await this.cacheRouteForDay(daySchedule.date, daySchedule.activities)
+        if (routeData) {
+          offlineData.routes!.push(routeData)
+        }
+      }
+
+      // 로컬 스토리지에 저장
+      localStorage.setItem(this.CACHE_KEY, JSON.stringify(offlineData))
+      
+      console.log('여행 계획이 오프라인용으로 캐시되었습니다')
+    } catch (error) {
+      console.error('오프라인 캐시 저장 실패:', error)
+    }
+  }
+
+  // 개별 활동을 캐시
+  private async cacheActivity(activity: Activity): Promise<CachedActivityData> {
+    const cachedActivity: CachedActivityData = {
+      id: activity.id,
+      title: activity.title,
+      location: activity.location || '',
+      coordinates: activity.coordinates,
+      description: activity.description,
+      time: activity.time,
+      type: activity.type,
+      cached_at: new Date().toISOString(),
+      source: 'manual', // 기본값
+      offline_data: {
+        address: activity.location || '',
+        category: this.getCategoryName(activity.type),
+        estimated_duration: this.estimateDuration(activity.type),
+        notes: activity.description
+      }
+    }
+
+    // Google Places에서 가져온 데이터라면 추가 정보 캐시
+    if (activity.coordinates && typeof window !== 'undefined' && window.google) {
+      try {
+        const placeDetails = await this.getPlaceDetailsForCache(activity.coordinates)
+        if (placeDetails) {
+          cachedActivity.offline_data.address = placeDetails.formatted_address || cachedActivity.offline_data.address
+          cachedActivity.source = 'google_places'
+          
+          // 작은 썸네일 이미지 캐시 (선택적)
+          if (placeDetails.photos && placeDetails.photos.length > 0) {
+            try {
+              const thumbnail = await this.createThumbnail(placeDetails.photos[0])
+              cachedActivity.offline_data.thumbnail = thumbnail
+            } catch (error) {
+              console.log('썸네일 생성 실패:', error)
+            }
+          }
+        }
+      } catch (error) {
+        console.log('장소 상세 정보 캐시 실패:', error)
+      }
+    }
+
+    return cachedActivity
+  }
+
+  // 하루 경로 정보 캐시
+  private async cacheRouteForDay(date: Date, activities: Activity[]) {
+    try {
+      // 좌표가 있는 활동들만 필터링
+      const activitiesWithCoords = activities.filter(a => a.coordinates)
+      
+      if (activitiesWithCoords.length < 2) {
+        return null
+      }
+
+      // Google Directions API가 사용 가능하다면 경로 정보 가져오기
+      if (typeof window !== 'undefined' && window.google && window.google.maps) {
+        // 이미 계산된 경로가 있는지 확인
+        const existingRoute = this.getExistingRoute(date, activitiesWithCoords)
+        if (existingRoute) {
+          return existingRoute
+        }
+      }
+
+      // 기본 경로 정보 생성 (직선 거리 기반 추정)
+      const waypoints = activitiesWithCoords.map(activity => ({
+        lat: activity.coordinates!.lat,
+        lng: activity.coordinates!.lng,
+        name: activity.title
+      }))
+
+      const estimatedDistance = this.calculateTotalDistance(waypoints)
+      const estimatedDuration = this.estimateRouteTime(waypoints, 'driving')
+
+      return {
+        day: date.toISOString().split('T')[0],
+        waypoints,
+        distance: `${estimatedDistance.toFixed(1)}km`,
+        duration: estimatedDuration,
+        instructions: this.generateBasicInstructions(waypoints)
+      }
+    } catch (error) {
+      console.error('경로 캐시 실패:', error)
+      return null
+    }
+  }
+
+  // 오프라인 데이터 로드
+  getOfflineData(): OfflineMapData | null {
+    try {
+      const cached = localStorage.getItem(this.CACHE_KEY)
+      if (!cached) return null
+
+      const data: OfflineMapData = JSON.parse(cached)
+      
+      // 캐시가 너무 오래되었는지 확인
+      const cacheAge = Date.now() - new Date(data.cached_at).getTime()
+      if (cacheAge > this.MAX_CACHE_AGE) {
+        console.log('오프라인 캐시가 만료되었습니다')
+        return null
+      }
+
+      return data
+    } catch (error) {
+      console.error('오프라인 데이터 로드 실패:', error)
+      return null
+    }
+  }
+
+  // 오프라인 모드에서 활동 표시용 데이터 생성
+  generateOfflineActivities(): CachedActivityData[] {
+    const offlineData = this.getOfflineData()
+    return offlineData?.activities || []
+  }
+
+  // 오프라인 모드에서 지도 마커 데이터 생성
+  generateOfflineMarkers() {
+    const activities = this.generateOfflineActivities()
+    
+    return activities
+      .filter(activity => activity.coordinates)
+      .map(activity => ({
+        id: activity.id,
+        position: activity.coordinates!,
+        title: activity.title,
+        description: activity.offline_data.address,
+        category: activity.offline_data.category,
+        time: activity.time,
+        type: activity.type
+      }))
+  }
+
+  // 카테고리 이름 변환
+  private getCategoryName(type: Activity['type']): string {
+    const categoryMap = {
+      'attraction': '관광지',
+      'food': '맛집',
+      'accommodation': '숙박',
+      'transport': '교통',
+      'other': '기타'
+    }
+    return categoryMap[type] || '기타'
+  }
+
+  // 예상 소요 시간 추정
+  private estimateDuration(type: Activity['type']): string {
+    const durationMap = {
+      'attraction': '1-2시간',
+      'food': '1시간',
+      'accommodation': '체크인/아웃',
+      'transport': '30분',
+      'other': '30분'
+    }
+    return durationMap[type] || '30분'
+  }
+
+  // 직선 거리 계산 (Haversine formula)
+  private calculateDistance(lat1: number, lng1: number, lat2: number, lng2: number): number {
+    const R = 6371 // 지구 반지름 (km)
+    const dLat = (lat2 - lat1) * Math.PI / 180
+    const dLng = (lng2 - lng1) * Math.PI / 180
+    const a = 
+      Math.sin(dLat/2) * Math.sin(dLat/2) +
+      Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) * 
+      Math.sin(dLng/2) * Math.sin(dLng/2)
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+    return R * c
+  }
+
+  // 총 거리 계산
+  private calculateTotalDistance(waypoints: { lat: number; lng: number }[]): number {
+    let totalDistance = 0
+    for (let i = 0; i < waypoints.length - 1; i++) {
+      const current = waypoints[i]
+      const next = waypoints[i + 1]
+      totalDistance += this.calculateDistance(current.lat, current.lng, next.lat, next.lng)
+    }
+    return totalDistance
+  }
+
+  // 경로 시간 추정
+  private estimateRouteTime(waypoints: { lat: number; lng: number }[], mode: 'driving' | 'walking' | 'transit'): string {
+    const totalDistance = this.calculateTotalDistance(waypoints)
+    
+    // 이동 수단별 평균 속도 (km/h)
+    const speedMap = {
+      'driving': 40,    // 시내 주행 고려
+      'walking': 4,     // 보행 속도
+      'transit': 25     // 대중교통 (환승 시간 포함)
+    }
+    
+    const speed = speedMap[mode]
+    const hours = totalDistance / speed
+    const minutes = Math.round(hours * 60)
+    
+    if (minutes >= 60) {
+      const h = Math.floor(minutes / 60)
+      const m = minutes % 60
+      return m > 0 ? `${h}시간 ${m}분` : `${h}시간`
+    } else {
+      return `${minutes}분`
+    }
+  }
+
+  // 기본 길찾기 안내 생성
+  private generateBasicInstructions(waypoints: { lat: number; lng: number; name: string }[]): string[] {
+    const instructions: string[] = []
+    
+    for (let i = 0; i < waypoints.length - 1; i++) {
+      const current = waypoints[i]
+      const next = waypoints[i + 1]
+      const distance = this.calculateDistance(current.lat, current.lng, next.lat, next.lng)
+      
+      instructions.push(`${current.name}에서 ${next.name}까지 약 ${distance.toFixed(1)}km`)
+    }
+    
+    return instructions
+  }
+
+  // 기존 경로 정보 확인 (임시)
+  private getExistingRoute(date: Date, activities: Activity[]) {
+    // 실제로는 이전에 계산된 Google Directions 결과를 확인
+    return null
+  }
+
+  // Google Places 상세 정보 가져오기 (캐시용)
+  private async getPlaceDetailsForCache(coordinates: { lat: number; lng: number }) {
+    // Google Places API를 사용해 상세 정보 가져오기
+    // 실제 구현에서는 googlePlacesService 사용
+    return null
+  }
+
+  // 썸네일 이미지 생성
+  private async createThumbnail(photo: google.maps.places.PlacePhoto): Promise<string> {
+    // 작은 썸네일 이미지를 base64로 변환
+    // 실제 구현에서는 Canvas API 사용
+    return ''
+  }
+
+  // 캐시 정리
+  clearCache(): void {
+    localStorage.removeItem(this.CACHE_KEY)
+    localStorage.removeItem(this.ACTIVITY_CACHE_KEY)
+    console.log('오프라인 캐시가 정리되었습니다')
+  }
+
+  // 캐시 상태 확인
+  getCacheStatus() {
+    const offlineData = this.getOfflineData()
+    
+    return {
+      hasCachedData: !!offlineData,
+      cachedActivities: offlineData?.activities.length || 0,
+      cachedRoutes: offlineData?.routes?.length || 0,
+      cacheAge: offlineData ? Date.now() - new Date(offlineData.cached_at).getTime() : 0,
+      isExpired: offlineData ? Date.now() - new Date(offlineData.cached_at).getTime() > this.MAX_CACHE_AGE : true
+    }
+  }
+}
+
+// 싱글톤 인스턴스
+export const offlineSupportService = new OfflineSupportService()
+
+// 오프라인 지원 유틸리티
+export const OfflineUtils = {
+  // API 사용 가능 여부 확인
+  isGoogleMapsAvailable(): boolean {
+    return typeof window !== 'undefined' && 
+           window.google && 
+           window.google.maps &&
+           !this.isApiLimitExceeded()
+  },
+
+  // API 한도 초과 여부 확인
+  isApiLimitExceeded(): boolean {
+    // googleMapsUsage 서비스와 연동
+    try {
+      const { canUseGoogleMaps } = require('../services/googleMapsUsage')
+      return !canUseGoogleMaps()
+    } catch {
+      return false
+    }
+  },
+
+  // 오프라인 모드 권장 여부
+  shouldUseOfflineMode(): boolean {
+    return !this.isGoogleMapsAvailable() || this.isApiLimitExceeded()
+  },
+
+  // 사용자에게 오프라인 모드 안내
+  getOfflineModeMessage(): string {
+    if (this.isApiLimitExceeded()) {
+      return '🚫 Google Maps API 한도에 도달했습니다. 오프라인 모드로 전환합니다.'
+    } else {
+      return '📱 오프라인 모드: 캐시된 데이터로 지도를 표시합니다.'
+    }
+  }
+} as const
diff --git a/src/services/tripManager.ts b/src/services/tripManager.ts
new file mode 100644
index 0000000..9a5d4c0
--- /dev/null
+++ b/src/services/tripManager.ts
@@ -0,0 +1,517 @@
+// 여행 계획 관리 서비스
+import { TravelPlan } from '../types'
+import { userAuthService } from './userAuth'
+
+export interface TripCreateData {
+  title: string
+  description?: string
+  destination: {
+    country: string
+    city: string
+    region?: string
+    coordinates?: {
+      lat: number
+      lng: number
+    }
+  }
+  startDate: Date
+  endDate: Date
+  template_category?: TravelPlan['template_category']
+  tags?: string[]
+  is_public?: boolean
+}
+
+export interface TripFilter {
+  user_id?: string
+  status?: TravelPlan['status']
+  template_category?: TravelPlan['template_category']
+  country?: string
+  is_template?: boolean
+  is_public?: boolean
+  search?: string
+  tags?: string[]
+}
+
+export interface TripListResponse {
+  trips: TravelPlan[]
+  total: number
+  page: number
+  limit: number
+}
+
+class TripManagerService {
+  private readonly API_BASE = '/api/trips'
+  private readonly STORAGE_KEY = 'user_trips'
+
+  // 사용자의 여행 목록 조회
+  async getUserTrips(filter?: TripFilter): Promise<TripListResponse> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      throw new Error('로그인이 필요합니다')
+    }
+
+    try {
+      const params = new URLSearchParams()
+      if (filter) {
+        Object.entries(filter).forEach(([key, value]) => {
+          if (value !== undefined) {
+            if (Array.isArray(value)) {
+              params.append(key, value.join(','))
+            } else {
+              params.append(key, value.toString())
+            }
+          }
+        })
+      }
+
+      const response = await fetch(`${this.API_BASE}?${params}`, {
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to fetch trips:', error)
+      
+      // 개발 환경에서는 로컬 스토리지 사용
+      if (import.meta.env.DEV) {
+        return this.getLocalUserTrips(currentUser.id, filter)
+      }
+      
+      return { trips: [], total: 0, page: 1, limit: 10 }
+    }
+  }
+
+  // 관리자용: 모든 여행 목록 조회
+  async getAllTrips(filter?: TripFilter): Promise<TripListResponse> {
+    if (!userAuthService.isAdmin()) {
+      throw new Error('관리자 권한이 필요합니다')
+    }
+
+    try {
+      const params = new URLSearchParams()
+      if (filter) {
+        Object.entries(filter).forEach(([key, value]) => {
+          if (value !== undefined) {
+            if (Array.isArray(value)) {
+              params.append(key, value.join(','))
+            } else {
+              params.append(key, value.toString())
+            }
+          }
+        })
+      }
+
+      const response = await fetch(`${this.API_BASE}/admin/all?${params}`, {
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to fetch all trips:', error)
+      
+      // 개발 환경에서는 로컬 스토리지 사용
+      if (import.meta.env.DEV) {
+        return this.getAllLocalTrips(filter)
+      }
+      
+      return { trips: [], total: 0, page: 1, limit: 10 }
+    }
+  }
+
+  // 새 여행 계획 생성
+  async createTrip(tripData: TripCreateData): Promise<{ success: boolean; trip?: TravelPlan; message?: string }> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      return { success: false, message: '로그인이 필요합니다' }
+    }
+
+    try {
+      const response = await fetch(this.API_BASE, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...userAuthService.getAuthHeaders()
+        },
+        body: JSON.stringify(tripData)
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to create trip:', error)
+      
+      // 개발 환경에서는 로컬 생성
+      if (import.meta.env.DEV) {
+        return this.createLocalTrip(currentUser.id, tripData)
+      }
+      
+      return { success: false, message: '여행 계획 생성 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 여행 계획 수정
+  async updateTrip(tripId: string, updates: Partial<TravelPlan>): Promise<{ success: boolean; trip?: TravelPlan; message?: string }> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      return { success: false, message: '로그인이 필요합니다' }
+    }
+
+    try {
+      const response = await fetch(`${this.API_BASE}/${tripId}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          ...userAuthService.getAuthHeaders()
+        },
+        body: JSON.stringify(updates)
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to update trip:', error)
+      
+      // 개발 환경에서는 로컬 수정
+      if (import.meta.env.DEV) {
+        return this.updateLocalTrip(tripId, updates)
+      }
+      
+      return { success: false, message: '여행 계획 수정 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 여행 계획 삭제
+  async deleteTrip(tripId: string): Promise<{ success: boolean; message?: string }> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      return { success: false, message: '로그인이 필요합니다' }
+    }
+
+    try {
+      const response = await fetch(`${this.API_BASE}/${tripId}`, {
+        method: 'DELETE',
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to delete trip:', error)
+      
+      // 개발 환경에서는 로컬 삭제
+      if (import.meta.env.DEV) {
+        return this.deleteLocalTrip(tripId)
+      }
+      
+      return { success: false, message: '여행 계획 삭제 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 여행 계획 복사
+  async duplicateTrip(tripId: string, newTitle?: string): Promise<{ success: boolean; trip?: TravelPlan; message?: string }> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      return { success: false, message: '로그인이 필요합니다' }
+    }
+
+    try {
+      const response = await fetch(`${this.API_BASE}/${tripId}/duplicate`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...userAuthService.getAuthHeaders()
+        },
+        body: JSON.stringify({ title: newTitle })
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to duplicate trip:', error)
+      
+      // 개발 환경에서는 로컬 복사
+      if (import.meta.env.DEV) {
+        return this.duplicateLocalTrip(tripId, newTitle)
+      }
+      
+      return { success: false, message: '여행 계획 복사 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 특정 여행 계획 조회
+  async getTrip(tripId: string): Promise<TravelPlan | null> {
+    try {
+      const response = await fetch(`${this.API_BASE}/${tripId}`, {
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      if (response.ok) {
+        const result = await response.json()
+        return result.trip
+      }
+      
+      return null
+    } catch (error) {
+      console.error('Failed to fetch trip:', error)
+      
+      // 개발 환경에서는 로컬 조회
+      if (import.meta.env.DEV) {
+        return this.getLocalTrip(tripId)
+      }
+      
+      return null
+    }
+  }
+
+  // 개발용 로컬 스토리지 메서드들
+  private getStoredTrips(): TravelPlan[] {
+    try {
+      const stored = localStorage.getItem(this.STORAGE_KEY)
+      return stored ? JSON.parse(stored) : []
+    } catch {
+      return []
+    }
+  }
+
+  private saveStoredTrips(trips: TravelPlan[]): void {
+    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(trips))
+  }
+
+  private getLocalUserTrips(userId: string, filter?: TripFilter): TripListResponse {
+    let trips = this.getStoredTrips().filter(trip => trip.user_id === userId)
+
+    // 필터 적용
+    if (filter) {
+      if (filter.status) {
+        trips = trips.filter(trip => trip.status === filter.status)
+      }
+      if (filter.template_category) {
+        trips = trips.filter(trip => trip.template_category === filter.template_category)
+      }
+      if (filter.country) {
+        trips = trips.filter(trip => trip.destination.country === filter.country)
+      }
+      if (filter.is_template !== undefined) {
+        trips = trips.filter(trip => trip.is_template === filter.is_template)
+      }
+      if (filter.search) {
+        const searchLower = filter.search.toLowerCase()
+        trips = trips.filter(trip => 
+          trip.title.toLowerCase().includes(searchLower) ||
+          trip.description?.toLowerCase().includes(searchLower) ||
+          trip.destination.city.toLowerCase().includes(searchLower)
+        )
+      }
+      if (filter.tags && filter.tags.length > 0) {
+        trips = trips.filter(trip => 
+          filter.tags!.some(tag => trip.tags.includes(tag))
+        )
+      }
+    }
+
+    // 최신순 정렬
+    trips.sort((a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime())
+
+    return {
+      trips,
+      total: trips.length,
+      page: 1,
+      limit: trips.length
+    }
+  }
+
+  private getAllLocalTrips(filter?: TripFilter): TripListResponse {
+    let trips = this.getStoredTrips()
+
+    // 필터 적용 (위와 동일한 로직)
+    if (filter) {
+      if (filter.user_id) {
+        trips = trips.filter(trip => trip.user_id === filter.user_id)
+      }
+      // ... 다른 필터들도 동일하게 적용
+    }
+
+    trips.sort((a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime())
+
+    return {
+      trips,
+      total: trips.length,
+      page: 1,
+      limit: trips.length
+    }
+  }
+
+  private createLocalTrip(userId: string, tripData: TripCreateData): { success: boolean; trip?: TravelPlan; message?: string } {
+    try {
+      const trips = this.getStoredTrips()
+      
+      const newTrip: TravelPlan = {
+        id: `trip_${Date.now()}`,
+        title: tripData.title,
+        description: tripData.description,
+        destination: tripData.destination,
+        startDate: tripData.startDate,
+        endDate: tripData.endDate,
+        schedule: [],
+        budget: {
+          total: 0,
+          accommodation: 0,
+          food: 0,
+          transportation: 0,
+          shopping: 0,
+          activities: 0
+        },
+        checklist: [],
+        user_id: userId,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        is_public: tripData.is_public || false,
+        is_template: false,
+        template_category: tripData.template_category,
+        tags: tripData.tags || [],
+        status: 'draft'
+      }
+
+      trips.push(newTrip)
+      this.saveStoredTrips(trips)
+
+      return { success: true, trip: newTrip, message: '여행 계획이 생성되었습니다' }
+    } catch (error) {
+      return { success: false, message: '여행 계획 생성 중 오류가 발생했습니다' }
+    }
+  }
+
+  private updateLocalTrip(tripId: string, updates: Partial<TravelPlan>): { success: boolean; trip?: TravelPlan; message?: string } {
+    try {
+      const trips = this.getStoredTrips()
+      const tripIndex = trips.findIndex(trip => trip.id === tripId)
+      
+      if (tripIndex === -1) {
+        return { success: false, message: '여행 계획을 찾을 수 없습니다' }
+      }
+
+      trips[tripIndex] = {
+        ...trips[tripIndex],
+        ...updates,
+        updated_at: new Date().toISOString()
+      }
+
+      this.saveStoredTrips(trips)
+
+      return { success: true, trip: trips[tripIndex], message: '여행 계획이 수정되었습니다' }
+    } catch (error) {
+      return { success: false, message: '여행 계획 수정 중 오류가 발생했습니다' }
+    }
+  }
+
+  private deleteLocalTrip(tripId: string): { success: boolean; message?: string } {
+    try {
+      const trips = this.getStoredTrips()
+      const filteredTrips = trips.filter(trip => trip.id !== tripId)
+      
+      if (trips.length === filteredTrips.length) {
+        return { success: false, message: '여행 계획을 찾을 수 없습니다' }
+      }
+
+      this.saveStoredTrips(filteredTrips)
+      return { success: true, message: '여행 계획이 삭제되었습니다' }
+    } catch (error) {
+      return { success: false, message: '여행 계획 삭제 중 오류가 발생했습니다' }
+    }
+  }
+
+  private duplicateLocalTrip(tripId: string, newTitle?: string): { success: boolean; trip?: TravelPlan; message?: string } {
+    try {
+      const trips = this.getStoredTrips()
+      const originalTrip = trips.find(trip => trip.id === tripId)
+      
+      if (!originalTrip) {
+        return { success: false, message: '원본 여행 계획을 찾을 수 없습니다' }
+      }
+
+      const duplicatedTrip: TravelPlan = {
+        ...originalTrip,
+        id: `trip_${Date.now()}`,
+        title: newTitle || `${originalTrip.title} (복사본)`,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        status: 'draft'
+      }
+
+      trips.push(duplicatedTrip)
+      this.saveStoredTrips(trips)
+
+      return { success: true, trip: duplicatedTrip, message: '여행 계획이 복사되었습니다' }
+    } catch (error) {
+      return { success: false, message: '여행 계획 복사 중 오류가 발생했습니다' }
+    }
+  }
+
+  private getLocalTrip(tripId: string): TravelPlan | null {
+    const trips = this.getStoredTrips()
+    return trips.find(trip => trip.id === tripId) || null
+  }
+}
+
+// 싱글톤 인스턴스
+export const tripManagerService = new TripManagerService()
+
+// 여행지 카테고리 정보
+export const TripCategories = {
+  japan: {
+    label: '🇯🇵 일본',
+    description: '일본 여행 (도쿄, 오사카, 교토, 구마모토 등)',
+    color: 'bg-red-100 text-red-800'
+  },
+  korea: {
+    label: '🇰🇷 한국',
+    description: '국내 여행 (서울, 부산, 제주도 등)',
+    color: 'bg-blue-100 text-blue-800'
+  },
+  asia: {
+    label: '🌏 아시아',
+    description: '아시아 여행 (중국, 태국, 베트남 등)',
+    color: 'bg-green-100 text-green-800'
+  },
+  europe: {
+    label: '🇪🇺 유럽',
+    description: '유럽 여행 (프랑스, 이탈리아, 독일 등)',
+    color: 'bg-purple-100 text-purple-800'
+  },
+  america: {
+    label: '🌎 아메리카',
+    description: '아메리카 여행 (미국, 캐나다, 브라질 등)',
+    color: 'bg-yellow-100 text-yellow-800'
+  },
+  other: {
+    label: '🌍 기타',
+    description: '기타 지역 여행',
+    color: 'bg-gray-100 text-gray-800'
+  }
+} as const
+
+// 여행 상태 정보
+export const TripStatus = {
+  draft: {
+    label: '📝 계획 중',
+    description: '여행 계획을 작성 중입니다',
+    color: 'bg-gray-100 text-gray-800'
+  },
+  active: {
+    label: '✈️ 여행 중',
+    description: '현재 여행을 진행 중입니다',
+    color: 'bg-blue-100 text-blue-800'
+  },
+  completed: {
+    label: '✅ 완료',
+    description: '여행이 완료되었습니다',
+    color: 'bg-green-100 text-green-800'
+  },
+  cancelled: {
+    label: '❌ 취소',
+    description: '여행이 취소되었습니다',
+    color: 'bg-red-100 text-red-800'
+  }
+} as const
diff --git a/src/services/tripSharing.ts b/src/services/tripSharing.ts
new file mode 100644
index 0000000..9da0bae
--- /dev/null
+++ b/src/services/tripSharing.ts
@@ -0,0 +1,395 @@
+// 여행 일정 공유 서비스
+import { ShareLink, TripComment, CollaborativeTrip, TravelPlan } from '../types'
+import { userAuthService } from './userAuth'
+import { tripManagerService } from './tripManager'
+
+export interface CreateShareLinkOptions {
+  trip_id: string
+  expires_in_days?: number
+  max_access_count?: number
+  permissions: {
+    can_view: boolean
+    can_edit: boolean
+    can_comment: boolean
+  }
+}
+
+export interface ShareLinkInfo {
+  share_code: string
+  share_url: string
+  expires_at?: string
+  permissions: ShareLink['permissions']
+  access_count: number
+  max_access_count?: number
+}
+
+class TripSharingService {
+  private readonly API_BASE = '/api/sharing'
+  private readonly STORAGE_KEY = 'shared_trips'
+  private readonly COMMENTS_KEY = 'trip_comments'
+
+  // 공유 링크 생성
+  async createShareLink(options: CreateShareLinkOptions): Promise<{ success: boolean; shareLink?: ShareLinkInfo; message?: string }> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      return { success: false, message: '로그인이 필요합니다' }
+    }
+
+    try {
+      const response = await fetch(`${this.API_BASE}/create`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...userAuthService.getAuthHeaders()
+        },
+        body: JSON.stringify(options)
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to create share link:', error)
+      
+      // 개발 환경에서는 로컬 생성
+      if (import.meta.env.DEV) {
+        return this.createLocalShareLink(currentUser.id, options)
+      }
+      
+      return { success: false, message: '공유 링크 생성 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 공유 링크로 여행 계획 조회
+  async getTripByShareCode(shareCode: string): Promise<{ success: boolean; trip?: CollaborativeTrip; message?: string }> {
+    try {
+      const response = await fetch(`${this.API_BASE}/trip/${shareCode}`, {
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to get shared trip:', error)
+      
+      // 개발 환경에서는 로컬 조회
+      if (import.meta.env.DEV) {
+        return this.getLocalSharedTrip(shareCode)
+      }
+      
+      return { success: false, message: '공유된 여행 계획을 불러올 수 없습니다' }
+    }
+  }
+
+  // 여행 계획의 공유 링크 목록 조회
+  async getShareLinks(tripId: string): Promise<ShareLink[]> {
+    try {
+      const response = await fetch(`${this.API_BASE}/links/${tripId}`, {
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      if (response.ok) {
+        const result = await response.json()
+        return result.shareLinks || []
+      }
+      
+      return []
+    } catch (error) {
+      console.error('Failed to get share links:', error)
+      
+      // 개발 환경에서는 로컬 조회
+      if (import.meta.env.DEV) {
+        return this.getLocalShareLinks(tripId)
+      }
+      
+      return []
+    }
+  }
+
+  // 공유 링크 비활성화
+  async deactivateShareLink(linkId: string): Promise<{ success: boolean; message?: string }> {
+    try {
+      const response = await fetch(`${this.API_BASE}/deactivate/${linkId}`, {
+        method: 'POST',
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to deactivate share link:', error)
+      
+      // 개발 환경에서는 로컬 처리
+      if (import.meta.env.DEV) {
+        return this.deactivateLocalShareLink(linkId)
+      }
+      
+      return { success: false, message: '공유 링크 비활성화 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 댓글 추가
+  async addComment(tripId: string, content: string): Promise<{ success: boolean; comment?: TripComment; message?: string }> {
+    const currentUser = userAuthService.getCurrentUser()
+    if (!currentUser) {
+      return { success: false, message: '로그인이 필요합니다' }
+    }
+
+    try {
+      const response = await fetch(`${this.API_BASE}/comments`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...userAuthService.getAuthHeaders()
+        },
+        body: JSON.stringify({ trip_id: tripId, content })
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to add comment:', error)
+      
+      // 개발 환경에서는 로컬 추가
+      if (import.meta.env.DEV) {
+        return this.addLocalComment(currentUser, tripId, content)
+      }
+      
+      return { success: false, message: '댓글 추가 중 오류가 발생했습니다' }
+    }
+  }
+
+  // 댓글 목록 조회
+  async getComments(tripId: string): Promise<TripComment[]> {
+    try {
+      const response = await fetch(`${this.API_BASE}/comments/${tripId}`, {
+        headers: userAuthService.getAuthHeaders()
+      })
+
+      if (response.ok) {
+        const result = await response.json()
+        return result.comments || []
+      }
+      
+      return []
+    } catch (error) {
+      console.error('Failed to get comments:', error)
+      
+      // 개발 환경에서는 로컬 조회
+      if (import.meta.env.DEV) {
+        return this.getLocalComments(tripId)
+      }
+      
+      return []
+    }
+  }
+
+  // 공유 URL 생성
+  generateShareUrl(shareCode: string): string {
+    const baseUrl = window.location.origin
+    return `${baseUrl}/shared/${shareCode}`
+  }
+
+  // 공유 코드 생성 (8자리 랜덤)
+  private generateShareCode(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+    let result = ''
+    for (let i = 0; i < 8; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length))
+    }
+    return result
+  }
+
+  // 개발용 로컬 스토리지 메서드들
+  private getStoredShareLinks(): ShareLink[] {
+    try {
+      const stored = localStorage.getItem(this.STORAGE_KEY)
+      return stored ? JSON.parse(stored) : []
+    } catch {
+      return []
+    }
+  }
+
+  private saveStoredShareLinks(shareLinks: ShareLink[]): void {
+    localStorage.setItem(this.STORAGE_KEY, JSON.stringify(shareLinks))
+  }
+
+  private getStoredComments(): TripComment[] {
+    try {
+      const stored = localStorage.getItem(this.COMMENTS_KEY)
+      return stored ? JSON.parse(stored) : []
+    } catch {
+      return []
+    }
+  }
+
+  private saveStoredComments(comments: TripComment[]): void {
+    localStorage.setItem(this.COMMENTS_KEY, JSON.stringify(comments))
+  }
+
+  private createLocalShareLink(userId: string, options: CreateShareLinkOptions): { success: boolean; shareLink?: ShareLinkInfo; message?: string } {
+    try {
+      const shareLinks = this.getStoredShareLinks()
+      const shareCode = this.generateShareCode()
+      
+      const expiresAt = options.expires_in_days 
+        ? new Date(Date.now() + options.expires_in_days * 24 * 60 * 60 * 1000).toISOString()
+        : undefined
+
+      const newShareLink: ShareLink = {
+        id: `share_${Date.now()}`,
+        trip_id: options.trip_id,
+        created_by: userId,
+        share_code: shareCode,
+        expires_at: expiresAt,
+        is_active: true,
+        access_count: 0,
+        max_access_count: options.max_access_count,
+        permissions: options.permissions,
+        created_at: new Date().toISOString()
+      }
+
+      shareLinks.push(newShareLink)
+      this.saveStoredShareLinks(shareLinks)
+
+      const shareUrl = this.generateShareUrl(shareCode)
+
+      return {
+        success: true,
+        shareLink: {
+          share_code: shareCode,
+          share_url: shareUrl,
+          expires_at: expiresAt,
+          permissions: options.permissions,
+          access_count: 0,
+          max_access_count: options.max_access_count
+        },
+        message: '공유 링크가 생성되었습니다'
+      }
+    } catch (error) {
+      return { success: false, message: '공유 링크 생성 중 오류가 발생했습니다' }
+    }
+  }
+
+  private async getLocalSharedTrip(shareCode: string): Promise<{ success: boolean; trip?: CollaborativeTrip; message?: string }> {
+    try {
+      const shareLinks = this.getStoredShareLinks()
+      const shareLink = shareLinks.find(link => 
+        link.share_code === shareCode && 
+        link.is_active &&
+        (!link.expires_at || new Date(link.expires_at) > new Date()) &&
+        (!link.max_access_count || link.access_count < link.max_access_count)
+      )
+
+      if (!shareLink) {
+        return { success: false, message: '유효하지 않거나 만료된 공유 링크입니다' }
+      }
+
+      // 접근 횟수 증가
+      shareLink.access_count += 1
+      shareLink.last_accessed = new Date().toISOString()
+      this.saveStoredShareLinks(shareLinks)
+
+      // 여행 계획 조회
+      const trip = await tripManagerService.getTrip(shareLink.trip_id)
+      if (!trip) {
+        return { success: false, message: '여행 계획을 찾을 수 없습니다' }
+      }
+
+      // 댓글 조회
+      const comments = this.getLocalComments(shareLink.trip_id)
+
+      const collaborativeTrip: CollaborativeTrip = {
+        trip,
+        share_link: shareLink,
+        comments,
+        collaborators: [
+          {
+            user_id: trip.user_id,
+            user_name: '여행 계획 작성자',
+            role: 'owner',
+            joined_at: trip.created_at
+          }
+        ]
+      }
+
+      return { success: true, trip: collaborativeTrip }
+    } catch (error) {
+      return { success: false, message: '공유된 여행 계획을 불러올 수 없습니다' }
+    }
+  }
+
+  private getLocalShareLinks(tripId: string): ShareLink[] {
+    const shareLinks = this.getStoredShareLinks()
+    return shareLinks.filter(link => link.trip_id === tripId)
+  }
+
+  private deactivateLocalShareLink(linkId: string): { success: boolean; message?: string } {
+    try {
+      const shareLinks = this.getStoredShareLinks()
+      const linkIndex = shareLinks.findIndex(link => link.id === linkId)
+      
+      if (linkIndex === -1) {
+        return { success: false, message: '공유 링크를 찾을 수 없습니다' }
+      }
+
+      shareLinks[linkIndex].is_active = false
+      this.saveStoredShareLinks(shareLinks)
+
+      return { success: true, message: '공유 링크가 비활성화되었습니다' }
+    } catch (error) {
+      return { success: false, message: '공유 링크 비활성화 중 오류가 발생했습니다' }
+    }
+  }
+
+  private addLocalComment(user: any, tripId: string, content: string): { success: boolean; comment?: TripComment; message?: string } {
+    try {
+      const comments = this.getStoredComments()
+      
+      const newComment: TripComment = {
+        id: `comment_${Date.now()}`,
+        trip_id: tripId,
+        user_id: user.id,
+        user_name: user.name,
+        content,
+        created_at: new Date().toISOString(),
+        is_edited: false
+      }
+
+      comments.push(newComment)
+      this.saveStoredComments(comments)
+
+      return { success: true, comment: newComment, message: '댓글이 추가되었습니다' }
+    } catch (error) {
+      return { success: false, message: '댓글 추가 중 오류가 발생했습니다' }
+    }
+  }
+
+  private getLocalComments(tripId: string): TripComment[] {
+    const comments = this.getStoredComments()
+    return comments
+      .filter(comment => comment.trip_id === tripId)
+      .sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime())
+  }
+}
+
+// 싱글톤 인스턴스
+export const tripSharingService = new TripSharingService()
+
+// 공유 권한 정보
+export const SharePermissions = {
+  view_only: {
+    label: '보기 전용',
+    description: '여행 계획을 볼 수만 있습니다',
+    permissions: { can_view: true, can_edit: false, can_comment: false }
+  },
+  comment: {
+    label: '댓글 가능',
+    description: '여행 계획을 보고 댓글을 달 수 있습니다',
+    permissions: { can_view: true, can_edit: false, can_comment: true }
+  },
+  edit: {
+    label: '편집 가능',
+    description: '여행 계획을 보고 편집할 수 있습니다',
+    permissions: { can_view: true, can_edit: true, can_comment: true }
+  }
+} as const
diff --git a/src/services/userAuth.ts b/src/services/userAuth.ts
new file mode 100644
index 0000000..fcd2c41
--- /dev/null
+++ b/src/services/userAuth.ts
@@ -0,0 +1,673 @@
+// 사용자 인증 및 계정 관리 서비스
+export interface User {
+  id: string
+  email: string
+  name: string
+  avatar?: string
+  role: 'admin' | 'user'
+  created_at: string
+  updated_at: string
+  created_by?: string // 관리자가 생성한 경우 관리자 ID
+  last_login?: string
+  is_active: boolean
+  preferences: {
+    default_currency: 'KRW' | 'JPY' | 'USD'
+    language: 'ko' | 'en' | 'ja'
+    theme: 'light' | 'dark'
+    map_provider: 'google' | 'leaflet'
+  }
+}
+
+export interface LoginCredentials {
+  email: string
+  password: string
+}
+
+export interface RegisterData {
+  email: string
+  password: string
+  name: string
+  role?: 'admin' | 'user'
+  created_by?: string // 관리자가 생성하는 경우
+}
+
+export interface AuthResponse {
+  success: boolean
+  user?: User
+  token?: string
+  message?: string
+}
+
+class UserAuthService {
+  private readonly API_BASE = '/api/auth'
+  private readonly TOKEN_KEY = 'travel_planner_token'
+  private readonly USER_KEY = 'travel_planner_user'
+
+  // 현재 로그인된 사용자
+  private currentUser: User | null = null
+
+  constructor() {
+    // 페이지 로드시 저장된 사용자 정보 복원
+    this.loadStoredUser()
+  }
+
+  // 회원가입
+  async register(data: RegisterData): Promise<AuthResponse> {
+    try {
+      const response = await fetch(`${this.API_BASE}/register`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(data)
+      })
+
+      const result = await response.json()
+
+      if (result.success && result.user && result.token) {
+        this.setAuthData(result.user, result.token)
+      }
+
+      return result
+    } catch (error) {
+      console.error('Registration failed:', error)
+      
+      // 개발 환경에서는 로컬 스토리지로 시뮬레이션
+      if (import.meta.env.DEV) {
+        return this.simulateRegister(data)
+      }
+      
+      return {
+        success: false,
+        message: '회원가입 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 로그인
+  async login(credentials: LoginCredentials): Promise<AuthResponse> {
+    try {
+      const response = await fetch(`${this.API_BASE}/login`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(credentials)
+      })
+
+      const result = await response.json()
+
+      if (result.success && result.user && result.token) {
+        this.setAuthData(result.user, result.token)
+      }
+
+      return result
+    } catch (error) {
+      console.error('Login failed:', error)
+      
+      // 개발 환경에서는 로컬 스토리지로 시뮬레이션
+      if (import.meta.env.DEV) {
+        return this.simulateLogin(credentials)
+      }
+      
+      return {
+        success: false,
+        message: '로그인 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 로그아웃
+  async logout(): Promise<void> {
+    try {
+      const token = this.getToken()
+      if (token) {
+        await fetch(`${this.API_BASE}/logout`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${token}`
+          }
+        })
+      }
+    } catch (error) {
+      console.error('Logout API failed:', error)
+    } finally {
+      this.clearAuthData()
+    }
+  }
+
+  // 토큰 갱신
+  async refreshToken(): Promise<boolean> {
+    try {
+      const token = this.getToken()
+      if (!token) return false
+
+      const response = await fetch(`${this.API_BASE}/refresh`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${token}`
+        }
+      })
+
+      const result = await response.json()
+
+      if (result.success && result.token) {
+        localStorage.setItem(this.TOKEN_KEY, result.token)
+        return true
+      }
+
+      return false
+    } catch (error) {
+      console.error('Token refresh failed:', error)
+      return false
+    }
+  }
+
+  // 사용자 정보 업데이트
+  async updateProfile(updates: Partial<User>): Promise<AuthResponse> {
+    try {
+      const token = this.getToken()
+      if (!token) {
+        return { success: false, message: '로그인이 필요합니다' }
+      }
+
+      const response = await fetch(`${this.API_BASE}/profile`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify(updates)
+      })
+
+      const result = await response.json()
+
+      if (result.success && result.user) {
+        this.currentUser = result.user
+        localStorage.setItem(this.USER_KEY, JSON.stringify(result.user))
+      }
+
+      return result
+    } catch (error) {
+      console.error('Profile update failed:', error)
+      return {
+        success: false,
+        message: '프로필 업데이트 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 현재 사용자 정보
+  getCurrentUser(): User | null {
+    return this.currentUser
+  }
+
+  // 로그인 상태 확인
+  isAuthenticated(): boolean {
+    return this.currentUser !== null && this.getToken() !== null
+  }
+
+  // 토큰 가져오기
+  getToken(): string | null {
+    return localStorage.getItem(this.TOKEN_KEY)
+  }
+
+  // 인증 헤더 생성
+  getAuthHeaders(): Record<string, string> {
+    const token = this.getToken()
+    return token ? { 'Authorization': `Bearer ${token}` } : {}
+  }
+
+  // 관리자 권한 확인
+  isAdmin(): boolean {
+    return this.currentUser?.role === 'admin'
+  }
+
+  // 관리자 전용: 모든 사용자 목록 조회
+  async getAllUsers(): Promise<User[]> {
+    if (!this.isAdmin()) {
+      throw new Error('관리자 권한이 필요합니다')
+    }
+
+    try {
+      const token = this.getToken()
+      const response = await fetch(`${this.API_BASE}/admin/users`, {
+        headers: {
+          'Authorization': `Bearer ${token}`
+        }
+      })
+
+      const result = await response.json()
+      return result.users || []
+    } catch (error) {
+      console.error('Failed to fetch users:', error)
+      
+      // 개발 환경에서는 로컬 스토리지 사용
+      if (import.meta.env.DEV) {
+        return this.getStoredUsers()
+      }
+      
+      return []
+    }
+  }
+
+  // 관리자 전용: 사용자 계정 생성
+  async createUser(userData: RegisterData): Promise<AuthResponse> {
+    if (!this.isAdmin()) {
+      return {
+        success: false,
+        message: '관리자 권한이 필요합니다'
+      }
+    }
+
+    try {
+      const token = this.getToken()
+      const response = await fetch(`${this.API_BASE}/admin/users`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify({
+          ...userData,
+          created_by: this.currentUser?.id
+        })
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to create user:', error)
+      
+      // 개발 환경에서는 시뮬레이션
+      if (import.meta.env.DEV) {
+        return this.simulateAdminCreateUser(userData)
+      }
+      
+      return {
+        success: false,
+        message: '사용자 생성 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 관리자 전용: 사용자 정보 수정
+  async updateUser(userId: string, updates: Partial<User>): Promise<AuthResponse> {
+    if (!this.isAdmin()) {
+      return {
+        success: false,
+        message: '관리자 권한이 필요합니다'
+      }
+    }
+
+    try {
+      const token = this.getToken()
+      const response = await fetch(`${this.API_BASE}/admin/users/${userId}`, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`
+        },
+        body: JSON.stringify(updates)
+      })
+
+      const result = await response.json()
+      return result
+    } catch (error) {
+      console.error('Failed to update user:', error)
+      
+      // 개발 환경에서는 시뮬레이션
+      if (import.meta.env.DEV) {
+        return this.simulateAdminUpdateUser(userId, updates)
+      }
+      
+      return {
+        success: false,
+        message: '사용자 정보 수정 중 오류가 발생했습니다'
+      }
+    }
+  }
+
+  // 관리자 전용: 사용자 계정 비활성화/활성화
+  async toggleUserStatus(userId: string): Promise<AuthResponse> {
+    if (!this.isAdmin()) {
+      return {
+        success: false,
+        message: '관리자 권한이 필요합니다'
+      }
+    }
+
+    const users = this.getStoredUsers()
+    const userIndex = users.findIndex(u => u.id === userId)
+    
+    if (userIndex === -1) {
+      return {
+        success: false,
+        message: '사용자를 찾을 수 없습니다'
+      }
+    }
+
+    users[userIndex].is_active = !users[userIndex].is_active
+    localStorage.setItem('dev_users', JSON.stringify(users))
+
+    return {
+      success: true,
+      user: users[userIndex],
+      message: `사용자가 ${users[userIndex].is_active ? '활성화' : '비활성화'}되었습니다`
+    }
+  }
+
+  // 관리자 전용: 사용자 삭제
+  async deleteUser(userId: string): Promise<AuthResponse> {
+    if (!this.isAdmin()) {
+      return {
+        success: false,
+        message: '관리자 권한이 필요합니다'
+      }
+    }
+
+    if (userId === this.currentUser?.id) {
+      return {
+        success: false,
+        message: '자신의 계정은 삭제할 수 없습니다'
+      }
+    }
+
+    const users = this.getStoredUsers()
+    const filteredUsers = users.filter(u => u.id !== userId)
+    
+    if (users.length === filteredUsers.length) {
+      return {
+        success: false,
+        message: '사용자를 찾을 수 없습니다'
+      }
+    }
+
+    localStorage.setItem('dev_users', JSON.stringify(filteredUsers))
+
+    // 비밀번호도 삭제
+    const passwords = this.getStoredPasswords()
+    const userToDelete = users.find(u => u.id === userId)
+    if (userToDelete) {
+      delete passwords[userToDelete.email]
+      localStorage.setItem('dev_passwords', JSON.stringify(passwords))
+    }
+
+    return {
+      success: true,
+      message: '사용자가 삭제되었습니다'
+    }
+  }
+
+  // 인증 데이터 설정
+  private setAuthData(user: User, token: string): void {
+    this.currentUser = user
+    localStorage.setItem(this.USER_KEY, JSON.stringify(user))
+    localStorage.setItem(this.TOKEN_KEY, token)
+  }
+
+  // 인증 데이터 삭제
+  private clearAuthData(): void {
+    this.currentUser = null
+    localStorage.removeItem(this.USER_KEY)
+    localStorage.removeItem(this.TOKEN_KEY)
+  }
+
+  // 저장된 사용자 정보 로드
+  private loadStoredUser(): void {
+    try {
+      const userStr = localStorage.getItem(this.USER_KEY)
+      const token = localStorage.getItem(this.TOKEN_KEY)
+      
+      if (userStr && token) {
+        this.currentUser = JSON.parse(userStr)
+      }
+    } catch (error) {
+      console.error('Failed to load stored user:', error)
+      this.clearAuthData()
+    }
+  }
+
+  // 개발 환경용 회원가입 시뮬레이션
+  private simulateRegister(data: RegisterData): AuthResponse {
+    const users = this.getStoredUsers()
+    
+    // 이메일 중복 확인
+    if (users.find(u => u.email === data.email)) {
+      return {
+        success: false,
+        message: '이미 사용 중인 이메일입니다'
+      }
+    }
+
+    // 새 사용자 생성
+    const newUser: User = {
+      id: `user_${Date.now()}`,
+      email: data.email,
+      name: data.name,
+      role: data.role || 'user',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      created_by: data.created_by,
+      is_active: true,
+      preferences: {
+        default_currency: 'KRW',
+        language: 'ko',
+        theme: 'light',
+        map_provider: 'leaflet'
+      }
+    }
+
+    // 사용자 목록에 추가
+    users.push(newUser)
+    localStorage.setItem('dev_users', JSON.stringify(users))
+    
+    // 비밀번호 저장 (개발용 - 실제로는 해시화 필요)
+    const passwords = this.getStoredPasswords()
+    passwords[data.email] = data.password
+    localStorage.setItem('dev_passwords', JSON.stringify(passwords))
+
+    // 토큰 생성
+    const token = `dev_token_${newUser.id}`
+    this.setAuthData(newUser, token)
+
+    return {
+      success: true,
+      user: newUser,
+      token: token,
+      message: '회원가입이 완료되었습니다'
+    }
+  }
+
+  // 개발 환경용 로그인 시뮬레이션
+  private simulateLogin(credentials: LoginCredentials): AuthResponse {
+    const users = this.getStoredUsers()
+    const passwords = this.getStoredPasswords()
+
+    const user = users.find(u => u.email === credentials.email)
+    
+    if (!user) {
+      return {
+        success: false,
+        message: '등록되지 않은 이메일입니다'
+      }
+    }
+
+    if (passwords[credentials.email] !== credentials.password) {
+      return {
+        success: false,
+        message: '비밀번호가 올바르지 않습니다'
+      }
+    }
+
+    if (!user.is_active) {
+      return {
+        success: false,
+        message: '비활성화된 계정입니다. 관리자에게 문의하세요'
+      }
+    }
+
+    // 마지막 로그인 시간 업데이트
+    user.last_login = new Date().toISOString()
+    const allUsers = this.getStoredUsers()
+    const userIndex = allUsers.findIndex(u => u.id === user.id)
+    if (userIndex !== -1) {
+      allUsers[userIndex] = user
+      localStorage.setItem('dev_users', JSON.stringify(allUsers))
+    }
+
+    // 토큰 생성
+    const token = `dev_token_${user.id}`
+    this.setAuthData(user, token)
+
+    return {
+      success: true,
+      user: user,
+      token: token,
+      message: '로그인되었습니다'
+    }
+  }
+
+  // 개발용 사용자 목록 가져오기
+  private getStoredUsers(): User[] {
+    try {
+      const stored = localStorage.getItem('dev_users')
+      return stored ? JSON.parse(stored) : []
+    } catch {
+      return []
+    }
+  }
+
+  // 개발용 비밀번호 목록 가져오기
+  private getStoredPasswords(): Record<string, string> {
+    try {
+      const stored = localStorage.getItem('dev_passwords')
+      return stored ? JSON.parse(stored) : {}
+    } catch {
+      return {}
+    }
+  }
+
+  // 관리자용 사용자 생성 시뮬레이션
+  private simulateAdminCreateUser(data: RegisterData): AuthResponse {
+    const users = this.getStoredUsers()
+    
+    // 이메일 중복 확인
+    if (users.find(u => u.email === data.email)) {
+      return {
+        success: false,
+        message: '이미 사용 중인 이메일입니다'
+      }
+    }
+
+    // 새 사용자 생성
+    const newUser: User = {
+      id: `user_${Date.now()}`,
+      email: data.email,
+      name: data.name,
+      role: data.role || 'user',
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      created_by: this.currentUser?.id,
+      is_active: true,
+      preferences: {
+        default_currency: 'KRW',
+        language: 'ko',
+        theme: 'light',
+        map_provider: 'leaflet'
+      }
+    }
+
+    // 사용자 목록에 추가
+    users.push(newUser)
+    localStorage.setItem('dev_users', JSON.stringify(users))
+    
+    // 비밀번호 저장
+    const passwords = this.getStoredPasswords()
+    passwords[data.email] = data.password
+    localStorage.setItem('dev_passwords', JSON.stringify(passwords))
+
+    return {
+      success: true,
+      user: newUser,
+      message: '사용자가 생성되었습니다'
+    }
+  }
+
+  // 관리자용 사용자 수정 시뮬레이션
+  private simulateAdminUpdateUser(userId: string, updates: Partial<User>): AuthResponse {
+    const users = this.getStoredUsers()
+    const userIndex = users.findIndex(u => u.id === userId)
+    
+    if (userIndex === -1) {
+      return {
+        success: false,
+        message: '사용자를 찾을 수 없습니다'
+      }
+    }
+
+    // 사용자 정보 업데이트
+    users[userIndex] = {
+      ...users[userIndex],
+      ...updates,
+      updated_at: new Date().toISOString()
+    }
+
+    localStorage.setItem('dev_users', JSON.stringify(users))
+
+    return {
+      success: true,
+      user: users[userIndex],
+      message: '사용자 정보가 수정되었습니다'
+    }
+  }
+
+  // 관리자 계정 존재 여부 확인
+  hasAdminAccount(): boolean {
+    const users = this.getStoredUsers()
+    return users.some(u => u.role === 'admin')
+  }
+}
+
+// 싱글톤 인스턴스
+export const userAuthService = new UserAuthService()
+
+// 인증 상태 변경 이벤트
+export class AuthStateManager {
+  private listeners: ((user: User | null) => void)[] = []
+
+  // 인증 상태 변경 리스너 등록
+  onAuthStateChange(callback: (user: User | null) => void): () => void {
+    this.listeners.push(callback)
+    
+    // 현재 상태로 즉시 호출
+    callback(userAuthService.getCurrentUser())
+    
+    // 리스너 제거 함수 반환
+    return () => {
+      const index = this.listeners.indexOf(callback)
+      if (index > -1) {
+        this.listeners.splice(index, 1)
+      }
+    }
+  }
+
+  // 인증 상태 변경 알림
+  notifyAuthStateChange(user: User | null): void {
+    this.listeners.forEach(callback => callback(user))
+  }
+}
+
+export const authStateManager = new AuthStateManager()
+
+// React Hook 스타일 유틸리티
+export const useAuth = () => {
+  return {
+    user: userAuthService.getCurrentUser(),
+    isAuthenticated: userAuthService.isAuthenticated(),
+    login: userAuthService.login.bind(userAuthService),
+    register: userAuthService.register.bind(userAuthService),
+    logout: userAuthService.logout.bind(userAuthService),
+    updateProfile: userAuthService.updateProfile.bind(userAuthService)
+  }
+}
diff --git a/src/types.ts b/src/types.ts
index 3c0359c..0727da6 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,6 +1,29 @@
-export interface DaySchedule {
-  date: Date
-  activities: Activity[]
+// 공통 타입
+export interface Coordinates {
+  lat: number
+  lng: number
+}
+
+export interface Link {
+  url: string
+  label?: string
+}
+
+// 일정 관련 타입
+export type ActivityType = 'attraction' | 'food' | 'accommodation' | 'transport' | 'other'
+export type RelatedPlaceCategory = 'restaurant' | 'attraction' | 'shopping' | 'accommodation' | 'other'
+
+export interface RelatedPlace {
+  id: string
+  name: string
+  description?: string
+  address?: string
+  coordinates?: Coordinates
+  memo?: string
+  willVisit?: boolean
+  category?: RelatedPlaceCategory
+  images?: string[]
+  links?: Link[]
 }
 
 export interface Activity {
@@ -9,7 +32,16 @@ export interface Activity {
   title: string
   description?: string
   location?: string
-  type: 'attraction' | 'food' | 'accommodation' | 'transport' | 'other'
+  type: ActivityType
+  coordinates?: Coordinates
+  relatedPlaces?: RelatedPlace[]
+  images?: string[]
+  links?: Link[]
+}
+
+export interface DaySchedule {
+  date: Date
+  activities: Activity[]
 }
 
 export interface Budget {
@@ -29,13 +61,35 @@ export interface ChecklistItem {
 }
 
 export interface TravelPlan {
+  id: string
+  title: string
+  description?: string
+  destination: {
+    country: string
+    city: string
+    region?: string
+    coordinates?: Coordinates
+  }
   startDate: Date
   endDate: Date
   schedule: DaySchedule[]
   budget: Budget
   checklist: ChecklistItem[]
+  // 새로운 필드들
+  user_id: string
+  created_at: string
+  updated_at: string
+  is_public: boolean
+  is_template: boolean
+  template_category?: 'japan' | 'korea' | 'asia' | 'europe' | 'america' | 'other'
+  tags: string[]
+  thumbnail?: string
+  status: 'draft' | 'active' | 'completed' | 'cancelled'
 }
 
+// 관광지 타입
+export type AttractionCategory = 'castle' | 'nature' | 'onsen' | 'temple' | 'food' | 'other'
+
 export interface Attraction {
   id: string
   name: string
@@ -45,10 +99,61 @@ export interface Attraction {
   estimatedTime: string
   admissionFee?: number
   imageUrl?: string
-  category: 'castle' | 'nature' | 'onsen' | 'temple' | 'food' | 'other'
-  coordinates?: {
-    lat: number
-    lng: number
-  }
+  category: AttractionCategory
+  coordinates?: Coordinates
+}
+
+// 기본 포인트 타입
+export type BasePointType = 'accommodation' | 'airport' | 'station' | 'parking' | 'other'
+
+export interface BasePoint {
+  id: string
+  name: string
+  address: string
+  type: BasePointType
+  coordinates: Coordinates
+  memo?: string
+}
+
+// 공유 관련 타입
+export interface ShareLink {
+  id: string
+  trip_id: string
+  created_by: string
+  share_code: string
+  expires_at?: string
+  is_active: boolean
+  access_count: number
+  max_access_count?: number
+  permissions: {
+    can_view: boolean
+    can_edit: boolean
+    can_comment: boolean
+  }
+  created_at: string
+  last_accessed?: string
+}
+
+export interface TripComment {
+  id: string
+  trip_id: string
+  user_id: string
+  user_name: string
+  content: string
+  created_at: string
+  updated_at?: string
+  is_edited: boolean
+}
+
+export interface CollaborativeTrip {
+  trip: TravelPlan
+  share_link: ShareLink
+  comments: TripComment[]
+  collaborators: {
+    user_id: string
+    user_name: string
+    role: 'owner' | 'editor' | 'viewer'
+    joined_at: string
+  }[]
 }
 
diff --git a/src/utils/categoryMapping.ts b/src/utils/categoryMapping.ts
new file mode 100644
index 0000000..2eb3eb6
--- /dev/null
+++ b/src/utils/categoryMapping.ts
@@ -0,0 +1,129 @@
+import { ActivityType, RelatedPlaceCategory, AttractionCategory, BasePointType } from '../types'
+
+/**
+ * Activity 타입에 대한 이모지 반환
+ */
+export const getActivityEmoji = (type: ActivityType): string => {
+  const emojiMap: Record<ActivityType, string> = {
+    attraction: '🏞️',
+    food: '🍴',
+    accommodation: '🏨',
+    transport: '🚗',
+    other: '📍'
+  }
+  return emojiMap[type] || '📍'
+}
+
+/**
+ * Activity 타입에 대한 한글 이름 반환
+ */
+export const getActivityName = (type: ActivityType): string => {
+  const nameMap: Record<ActivityType, string> = {
+    attraction: '관광지',
+    food: '식사',
+    accommodation: '숙소',
+    transport: '교통',
+    other: '기타'
+  }
+  return nameMap[type] || '기타'
+}
+
+/**
+ * RelatedPlace 카테고리에 대한 이모지 반환
+ */
+export const getRelatedPlaceCategoryEmoji = (category: RelatedPlaceCategory): string => {
+  const emojiMap: Record<RelatedPlaceCategory, string> = {
+    restaurant: '🍴',
+    attraction: '🏞️',
+    shopping: '🛍️',
+    accommodation: '🏨',
+    other: '📍'
+  }
+  return emojiMap[category] || '📍'
+}
+
+/**
+ * RelatedPlace 카테고리에 대한 한글 이름 반환
+ */
+export const getRelatedPlaceCategoryName = (category: RelatedPlaceCategory): string => {
+  const nameMap: Record<RelatedPlaceCategory, string> = {
+    restaurant: '식당',
+    attraction: '관광지',
+    shopping: '쇼핑',
+    accommodation: '숙소',
+    other: '기타'
+  }
+  return nameMap[category] || '기타'
+}
+
+/**
+ * RelatedPlace 카테고리에 대한 배경색 반환 (Tailwind CSS 클래스)
+ */
+export const getRelatedPlaceCategoryColor = (category: RelatedPlaceCategory): string => {
+  const colorMap: Record<RelatedPlaceCategory, string> = {
+    restaurant: 'bg-orange-500',
+    attraction: 'bg-blue-500',
+    shopping: 'bg-pink-500',
+    accommodation: 'bg-purple-500',
+    other: 'bg-gray-500'
+  }
+  return colorMap[category] || 'bg-gray-500'
+}
+
+/**
+ * Attraction 카테고리에 대한 이모지 반환
+ */
+export const getAttractionCategoryEmoji = (category: AttractionCategory): string => {
+  const emojiMap: Record<AttractionCategory, string> = {
+    castle: '🏯',
+    nature: '🏞️',
+    onsen: '♨️',
+    temple: '⛩️',
+    food: '🍴',
+    other: '📍'
+  }
+  return emojiMap[category] || '📍'
+}
+
+/**
+ * Attraction 카테고리에 대한 한글 이름 반환
+ */
+export const getAttractionCategoryName = (category: AttractionCategory): string => {
+  const nameMap: Record<AttractionCategory, string> = {
+    castle: '성',
+    nature: '자연',
+    onsen: '온천',
+    temple: '신사/사찰',
+    food: '맛집',
+    other: '기타'
+  }
+  return nameMap[category] || '기타'
+}
+
+/**
+ * BasePoint 타입에 대한 이모지 반환
+ */
+export const getBasePointEmoji = (type: BasePointType): string => {
+  const emojiMap: Record<BasePointType, string> = {
+    accommodation: '🏨',
+    airport: '✈️',
+    station: '🚉',
+    parking: '🅿️',
+    other: '📍'
+  }
+  return emojiMap[type] || '📍'
+}
+
+/**
+ * BasePoint 타입에 대한 한글 이름 반환
+ */
+export const getBasePointName = (type: BasePointType): string => {
+  const nameMap: Record<BasePointType, string> = {
+    accommodation: '숙소',
+    airport: '공항',
+    station: '역',
+    parking: '주차장',
+    other: '기타'
+  }
+  return nameMap[type] || '기타'
+}
diff --git a/src/utils/env.ts b/src/utils/env.ts
new file mode 100644
index 0000000..8207c14
--- /dev/null
+++ b/src/utils/env.ts
@@ -0,0 +1,34 @@
+// 환경 변수 유틸리티
+// Vite 환경에서 안전하게 환경 변수에 접근하기 위한 유틸리티
+
+export const isDevelopment = import.meta.env.DEV
+export const isProduction = import.meta.env.PROD
+export const mode = import.meta.env.MODE
+
+// Google OAuth Client ID
+export const googleOAuthClientId = import.meta.env.VITE_GOOGLE_OAUTH_CLIENT_ID || ''
+
+// API URL
+export const apiUrl = import.meta.env.VITE_API_URL || 'http://localhost:3001'
+
+// 개발 환경 여부 확인 함수
+export const checkDevelopment = (): boolean => {
+  return isDevelopment
+}
+
+// 프로덕션 환경 여부 확인 함수  
+export const checkProduction = (): boolean => {
+  return isProduction
+}
+
+// 환경 변수 로깅 (개발 환경에서만)
+export const logEnvInfo = (): void => {
+  if (isDevelopment) {
+    console.log('Environment Info:', {
+      mode,
+      isDevelopment,
+      isProduction,
+      googleOAuthClientId: googleOAuthClientId ? '설정됨' : '미설정'
+    })
+  }
+}
diff --git a/start-server.sh b/start-server.sh
new file mode 100644
index 0000000..8475ad3
--- /dev/null
+++ b/start-server.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Kumamoto Travel Planner Server 시작 스크립트
+
+echo "🚀 Kumamoto Travel Planner Server 시작 중..."
+
+# 서버 디렉토리로 이동
+cd server
+
+# .env 파일 확인
+if [ ! -f .env ]; then
+    echo "⚠️  .env 파일이 없습니다. env.example을 참고해서 .env 파일을 생성하세요."
+    echo "📋 필수 환경 변수:"
+    echo "   - DATABASE_URL: PostgreSQL 연결 문자열"
+    echo "   - JWT_SECRET: JWT 토큰 시크릿 키"
+    echo ""
+    echo "💡 예시:"
+    echo "   cp env.example .env"
+    echo "   nano .env"
+    echo ""
+    read -p "계속하시겠습니까? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        exit 1
+    fi
+fi
+
+# 의존성 설치
+echo "📦 의존성 설치 중..."
+npm install
+
+# 데이터베이스 연결 테스트
+echo "🔍 데이터베이스 연결 테스트 중..."
+if [ -f .env ]; then
+    source .env
+fi
+
+# 서버 시작
+echo "🌟 서버 시작..."
+npm run dev
diff --git a/tailwind.config.js b/tailwind.config.js
index 4007c4e..6d8f402 100644
--- a/tailwind.config.js
+++ b/tailwind.config.js
@@ -11,6 +11,9 @@ export default {
           green: '#4A7C59',
           blue: '#5B8FA8',
           light: '#F5F7F6',
+          primary: '#E74C3C',     // 밝은 빨강 - 헤더 배경
+          secondary: '#C0392B',   // 진한 빨강 - 버튼 등
+          accent: '#F39C12',      // 주황색 - 강조 요소
         }
       }
     },