daiso 1.0.6 → 1.0.7

package/README.md

@@ -7,7 +7,7 @@
 
 # Daiso MCP 및 Skill
 
-다이소(제품/매장/재고), 롯데마트(매장/상품), GS25(매장/상품/재고), 세븐일레븐(상품/매장/재고/인기검색어/카탈로그), CU(매장/재고), 이마트24(매장/상품/재고), 올리브영(매장/재고), 메가박스(지점/영화/시간표/좌석), 롯데시네마(지점/영화/좌석), CGV(극장/영화/시간표) 조회 기능을 MCP, CLI, Codex Skill로 AI에 연결합니다.
+다이소(제품/매장/재고), 주변 음식점/카페, 롯데마트(매장/상품), GS25(매장/상품/재고), 세븐일레븐(상품/매장/재고/인기검색어/카탈로그), CU(매장/재고), 이마트24(매장/상품/재고), 올리브영(매장/재고), 메가박스(지점/영화/시간표/좌석), 롯데시네마(지점/영화/좌석), CGV(극장/영화/시간표) 조회 기능을 MCP, CLI, Codex Skill로 AI에 연결합니다.
 
 <br>
 
@@ -19,6 +19,42 @@
 
 <br>
 
+<h3>지원 서비스</h3>
+
+<table>
+  <thead>
+    <tr>
+      <th>분류</th>
+      <th>서비스</th>
+      <th>조회 기능</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>장소</td>
+      <td>네이버 지역 검색</td>
+      <td>음식점, 카페, 디저트, 주변 장소</td>
+    </tr>
+    <tr>
+      <td>리테일</td>
+      <td>다이소, 올리브영, 롯데마트</td>
+      <td>상품, 매장, 재고</td>
+    </tr>
+    <tr>
+      <td>편의점</td>
+      <td>GS25, 세븐일레븐, CU, 이마트24</td>
+      <td>상품, 매장, 재고, 인기검색어, 카탈로그</td>
+    </tr>
+    <tr>
+      <td>영화관</td>
+      <td>CGV, 메가박스, 롯데시네마</td>
+      <td>극장, 영화, 시간표, 잔여 좌석</td>
+    </tr>
+  </tbody>
+</table>
+
+<br>
+
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Cloudflare Workers](https://img.shields.io/badge/Cloudflare-Workers-F38020.svg)](https://workers.cloudflare.com/)
 [![MCP](https://img.shields.io/badge/MCP-Protocol-8B5CF6.svg)](https://modelcontextprotocol.io/)
@@ -29,11 +65,11 @@
 **[실시간 서비스 상태 보기](https://aka-page.betteruptime.com/)**
 
 <!-- WORKERS_INVOCATIONS_CHART:START -->
-<h3>Cloudflare Workers 호출량 (2026-03-01 ~ 2026-05-19, 80일)</h3>
+<h3>Cloudflare Workers 호출량 (2026-03-01 ~ 2026-05-21, 82일)</h3>
 
-<img src="./assets/analytics/workers-invocations.png?v=2026-05-19T16:35:34.414Z" alt="Cloudflare Workers 호출량 그래프 (2026-03-01 ~ 2026-05-19)" width="100%">
+<img src="./assets/analytics/workers-invocations.png?v=2026-05-23T04:50:41.937Z" alt="Cloudflare Workers 호출량 그래프 (2026-03-01 ~ 2026-05-21)" width="100%">
 
-<sub>기준 워커: <code>daiso-mcp</code> · 마지막 갱신: 2026-05-20 01:35 KST</sub>
+<sub>기준 워커: <code>daiso-mcp</code> · 마지막 갱신: 2026-05-23 13:50 KST</sub>
 
 <!-- WORKERS_INVOCATIONS_CHART:END -->
 
@@ -78,6 +114,8 @@ GS25 mcp로 강남 근처 매장과 오감자 재고 알려줘
 세븐일레븐 mcp로 안산 중앙역 근처 매장 찾아줘
 세븐일레븐 mcp로 안산 중앙역 근처 세븐일레븐에서 핫식스 재고 알려줘
 세븐일레븐 mcp로 인기 검색어와 카탈로그 요약 알려줘
+강남역 근처 카페 찾아줘
+성수동 근처 브런치 음식점 찾아줘
 메가박스 mcp로 강남점 영화와 잔여 좌석 알려줘
 롯데시네마 mcp로 월드타워 근처 지점과 상영 영화 알려줘
 롯데시네마 mcp로 월드타워 잔여 좌석 알려줘
@@ -171,6 +209,19 @@ AI: (https://mcp.aka.page/api/cgv/timetable?playDate=20260315&keyword=안산%20
 
 <br>
 
+### 바로 실행해보기
+
+AI 앱 연동 없이 터미널에서 바로 확인할 수 있습니다.
+
+```bash
+npx daiso products 수납박스 --json
+npx daiso places 강남역 --category cafe --limit 5 --json
+npx daiso gs25-inventory 오감자 --storeKeyword 강남 --storeLimit 5 --json
+npx daiso get /api/cgv/movies --playDate 20260520 --theaterCode 0056 --json
+```
+
+<br>
+
 ### MCP 서버 URL / CLI (고급)
 
 AI 앱 대신 직접 연결하거나 스크립트에서 사용할 때만 참고하세요.
@@ -203,6 +254,8 @@ npx daiso product 1034604
 npx daiso stores 강남역
 npx daiso inventory 1034604 --keyword 강남역
 npx daiso display-location 1034604 04515
+npx daiso places 강남역 --category cafe --limit 5
+npx daiso places 성수동 --keyword 브런치 --limit 5
 npx daiso cu-stores 강남
 npx daiso cu-inventory 과자 --storeKeyword 강남
 npx daiso lottemart-stores 잠실 --area 서울 --limit 10
@@ -249,11 +302,14 @@ MCP 도구 응답은 각 서비스의 원본 필드를 유지하면서, 클라
 - `standard.products`: 상품/영화 목록을 `code`, `name`, `price`, `imageUrl`, `raw` 형태로 정규화합니다.
 - `standard.stores`: 매장 목록을 `code`, `name`, `address`, `distanceMeters`, `raw` 형태로 정규화합니다.
 - `standard.theaters`: 영화관 목록을 `code`, `name`, `address`, `distanceMeters`, `raw` 형태로 정규화합니다.
+- `standard.places`: 음식점/카페 같은 장소 목록을 `name`, `address`, `raw` 중심으로 정규화합니다.
 
 ### 운영 헬스 체크
 
 공개 상태 페이지: **[Daiso MCP Status](https://aka-page.betteruptime.com/)**
 
+주변 음식점/카페 검색은 네이버 지역 검색 API를 사용합니다. 로컬 실행이나 배포 환경에는 `NAVER_CLIENT_ID`, `NAVER_CLIENT_SECRET`을 설정하세요.
+
 서비스별 API 상태를 즉시 확인할 때는 `GET /api/health/checks`를 사용합니다. 이 엔드포인트는 `HEALTH_CHECK_SECRET` 환경 변수가 설정되어 있어야 하며, 요청에는 `Authorization: Bearer <secret>` 또는 `x-health-check-key: <secret>` 헤더가 필요합니다. 내부 체크 요청의 기준 URL은 `HEALTH_CHECK_BASE_URL`로 지정할 수 있습니다.
 
 ```bash

package/dist/api/actionsProxy.js

@@ -3,34 +3,124 @@
  */
 export const ACTION_QUERY_DEFINITIONS = [
     { action: 'daisoSearchProducts', summary: '다이소 제품 검색', targetPath: '/api/daiso/products' },
-    { action: 'daisoGetProduct', summary: '다이소 제품 상세 조회', targetPath: '/api/daiso/products/:productId', pathParam: 'productId' },
+    {
+        action: 'daisoGetProduct',
+        summary: '다이소 제품 상세 조회',
+        targetPath: '/api/daiso/products/:productId',
+        pathParam: 'productId',
+    },
     { action: 'daisoFindStores', summary: '다이소 매장 검색', targetPath: '/api/daiso/stores' },
-    { action: 'daisoCheckInventory', summary: '다이소 재고 조회', targetPath: '/api/daiso/inventory' },
-    { action: 'daisoGetDisplayLocation', summary: '다이소 진열 위치 조회', targetPath: '/api/daiso/display-location' },
-    { action: 'oliveyoungSearchProducts', summary: '올리브영 상품 검색', targetPath: '/api/oliveyoung/products' },
-    { action: 'oliveyoungFindStores', summary: '올리브영 매장 검색', targetPath: '/api/oliveyoung/stores' },
-    { action: 'oliveyoungCheckInventory', summary: '올리브영 재고 조회', targetPath: '/api/oliveyoung/inventory' },
+    {
+        action: 'daisoCheckInventory',
+        summary: '다이소 재고 조회',
+        targetPath: '/api/daiso/inventory',
+    },
+    {
+        action: 'daisoGetDisplayLocation',
+        summary: '다이소 진열 위치 조회',
+        targetPath: '/api/daiso/display-location',
+    },
+    {
+        action: 'oliveyoungSearchProducts',
+        summary: '올리브영 상품 검색',
+        targetPath: '/api/oliveyoung/products',
+    },
+    {
+        action: 'oliveyoungFindStores',
+        summary: '올리브영 매장 검색',
+        targetPath: '/api/oliveyoung/stores',
+    },
+    {
+        action: 'oliveyoungCheckInventory',
+        summary: '올리브영 재고 조회',
+        targetPath: '/api/oliveyoung/inventory',
+    },
     { action: 'cuFindStores', summary: 'CU 매장 검색', targetPath: '/api/cu/stores' },
     { action: 'cuCheckInventory', summary: 'CU 재고 조회', targetPath: '/api/cu/inventory' },
     { action: 'emart24FindStores', summary: '이마트24 매장 검색', targetPath: '/api/emart24/stores' },
-    { action: 'emart24SearchProducts', summary: '이마트24 상품 검색', targetPath: '/api/emart24/products' },
-    { action: 'emart24CheckInventory', summary: '이마트24 재고 조회', targetPath: '/api/emart24/inventory' },
-    { action: 'lottemartFindStores', summary: '롯데마트 매장 검색', targetPath: '/api/lottemart/stores' },
-    { action: 'lottemartSearchProducts', summary: '롯데마트 상품 검색', targetPath: '/api/lottemart/products' },
+    {
+        action: 'emart24SearchProducts',
+        summary: '이마트24 상품 검색',
+        targetPath: '/api/emart24/products',
+    },
+    {
+        action: 'emart24CheckInventory',
+        summary: '이마트24 재고 조회',
+        targetPath: '/api/emart24/inventory',
+    },
+    {
+        action: 'lottemartFindStores',
+        summary: '롯데마트 매장 검색',
+        targetPath: '/api/lottemart/stores',
+    },
+    {
+        action: 'lottemartSearchProducts',
+        summary: '롯데마트 상품 검색',
+        targetPath: '/api/lottemart/products',
+    },
     { action: 'gs25FindStores', summary: 'GS25 매장 검색', targetPath: '/api/gs25/stores' },
     { action: 'gs25SearchProducts', summary: 'GS25 상품 검색', targetPath: '/api/gs25/products' },
     { action: 'gs25CheckInventory', summary: 'GS25 재고 조회', targetPath: '/api/gs25/inventory' },
-    { action: 'sevenelevenSearchProducts', summary: '세븐일레븐 상품 검색', targetPath: '/api/seveneleven/products' },
-    { action: 'sevenelevenSearchStores', summary: '세븐일레븐 매장 검색', targetPath: '/api/seveneleven/stores' },
-    { action: 'sevenelevenCheckInventory', summary: '세븐일레븐 재고 조회', targetPath: '/api/seveneleven/inventory' },
-    { action: 'sevenelevenGetPopwords', summary: '세븐일레븐 인기 검색어 조회', targetPath: '/api/seveneleven/popwords' },
-    { action: 'sevenelevenGetCatalog', summary: '세븐일레븐 카탈로그 조회', targetPath: '/api/seveneleven/catalog' },
-    { action: 'megaboxFindTheaters', summary: '메가박스 지점 검색', targetPath: '/api/megabox/theaters' },
-    { action: 'megaboxListMovies', summary: '메가박스 영화 목록 조회', targetPath: '/api/megabox/movies' },
-    { action: 'megaboxGetSeats', summary: '메가박스 잔여 좌석 조회', targetPath: '/api/megabox/seats' },
-    { action: 'lottecinemaFindTheaters', summary: '롯데시네마 지점 검색', targetPath: '/api/lottecinema/theaters' },
-    { action: 'lottecinemaListMovies', summary: '롯데시네마 영화 목록 조회', targetPath: '/api/lottecinema/movies' },
-    { action: 'lottecinemaGetSeats', summary: '롯데시네마 잔여 좌석 조회', targetPath: '/api/lottecinema/seats' },
+    {
+        action: 'sevenelevenSearchProducts',
+        summary: '세븐일레븐 상품 검색',
+        targetPath: '/api/seveneleven/products',
+    },
+    {
+        action: 'sevenelevenSearchStores',
+        summary: '세븐일레븐 매장 검색',
+        targetPath: '/api/seveneleven/stores',
+    },
+    {
+        action: 'sevenelevenCheckInventory',
+        summary: '세븐일레븐 재고 조회',
+        targetPath: '/api/seveneleven/inventory',
+    },
+    {
+        action: 'sevenelevenGetPopwords',
+        summary: '세븐일레븐 인기 검색어 조회',
+        targetPath: '/api/seveneleven/popwords',
+    },
+    {
+        action: 'sevenelevenGetCatalog',
+        summary: '세븐일레븐 카탈로그 조회',
+        targetPath: '/api/seveneleven/catalog',
+    },
+    {
+        action: 'placesSearchNearby',
+        summary: '음식점/카페 등 주변 장소 검색',
+        targetPath: '/api/places/search',
+    },
+    {
+        action: 'megaboxFindTheaters',
+        summary: '메가박스 지점 검색',
+        targetPath: '/api/megabox/theaters',
+    },
+    {
+        action: 'megaboxListMovies',
+        summary: '메가박스 영화 목록 조회',
+        targetPath: '/api/megabox/movies',
+    },
+    {
+        action: 'megaboxGetSeats',
+        summary: '메가박스 잔여 좌석 조회',
+        targetPath: '/api/megabox/seats',
+    },
+    {
+        action: 'lottecinemaFindTheaters',
+        summary: '롯데시네마 지점 검색',
+        targetPath: '/api/lottecinema/theaters',
+    },
+    {
+        action: 'lottecinemaListMovies',
+        summary: '롯데시네마 영화 목록 조회',
+        targetPath: '/api/lottecinema/movies',
+    },
+    {
+        action: 'lottecinemaGetSeats',
+        summary: '롯데시네마 잔여 좌석 조회',
+        targetPath: '/api/lottecinema/seats',
+    },
     { action: 'cgvFindTheaters', summary: 'CGV 극장 검색', targetPath: '/api/cgv/theaters' },
     { action: 'cgvSearchMovies', summary: 'CGV 영화 목록 조회', targetPath: '/api/cgv/movies' },
     { action: 'cgvGetTimetable', summary: 'CGV 시간표 조회', targetPath: '/api/cgv/timetable' },

package/dist/api/configStatus.js

@@ -9,7 +9,11 @@ export function buildConfigStatus(bindings) {
         },
         zyteApiKey: {
             configured: isConfigured(bindings?.ZYTE_API_KEY),
-            usedBy: ['oliveyoung', 'lottemart', 'cgv'],
+            usedBy: ['oliveyoung', 'gs25', 'lottemart', 'cgv'],
+        },
+        naverLocalSearch: {
+            configured: isConfigured(bindings?.NAVER_CLIENT_ID) && isConfigured(bindings?.NAVER_CLIENT_SECRET),
+            usedBy: ['places'],
         },
         healthCheckSecret: {
             configured: isConfigured(bindings?.HEALTH_CHECK_SECRET),

package/dist/api/gs25Handlers.js

@@ -3,7 +3,7 @@
  */
 /* c8 ignore start */
 import { errorResponse, successResponse } from './response.js';
-import { attachDistanceToGs25Stores, fetchGs25SearchProducts, fetchGs25Stores, filterGs25StoresByKeyword, geocodeGs25Address, selectGs25StoresForKeyword, sortGs25Stores, } from '../services/gs25/client.js';
+import { attachDistanceToGs25Stores, fetchGs25SearchProducts, fetchGs25Stores, fetchGs25WebStores, filterGs25StoresByKeyword, geocodeGs25Address, selectGs25StoresForKeyword, sortGs25Stores, } from '../services/gs25/client.js';
 const GS25_FALLBACK_STORE_LOOKUP_ITEM_CODE = '8801117752804';
 /**
  * GS25 매장 검색 API 핸들러
@@ -21,7 +21,8 @@ export async function handleGs25FindStores(c) {
     let longitude = typeof parsedLng === 'number' && Number.isFinite(parsedLng) ? parsedLng : undefined;
     let geocodeUsed = false;
     try {
-        if ((typeof latitude !== 'number' || typeof longitude !== 'number') && keyword.trim().length > 0) {
+        if ((typeof latitude !== 'number' || typeof longitude !== 'number') &&
+            keyword.trim().length > 0) {
             const geocoded = await geocodeGs25Address(keyword, {
                 timeout: 15000,
                 googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
@@ -38,9 +39,12 @@ export async function handleGs25FindStores(c) {
             longitude,
         }, {
             timeout: 20000,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
         });
         let fallbackUsed = false;
-        if (storeResult.stores.length === 0 && typeof latitude === 'number' && typeof longitude === 'number') {
+        if (storeResult.stores.length === 0 &&
+            typeof latitude === 'number' &&
+            typeof longitude === 'number') {
             try {
                 const fallbackResult = await fetchGs25Stores({
                     serviceCode,
@@ -51,6 +55,7 @@ export async function handleGs25FindStores(c) {
                     useCache: false,
                 }, {
                     timeout: 20000,
+                    zyteApiKey: c.env?.ZYTE_API_KEY,
                 });
                 if (fallbackResult.stores.length > 0) {
                     storeResult = fallbackResult;
@@ -61,6 +66,24 @@ export async function handleGs25FindStores(c) {
                 fallbackUsed = false;
             }
         }
+        if (storeResult.stores.length === 0 && keyword.trim().length > 0) {
+            try {
+                const webStoreResult = await fetchGs25WebStores(keyword, {
+                    timeout: 20000,
+                });
+                if (webStoreResult.stores.length > 0) {
+                    storeResult = {
+                        totalCount: webStoreResult.totalCount,
+                        stores: webStoreResult.stores,
+                        cacheHit: false,
+                    };
+                    fallbackUsed = true;
+                }
+            }
+            catch {
+                fallbackUsed = false;
+            }
+        }
         const selected = selectGs25StoresForKeyword(storeResult.stores, keyword, {
             relaxWhenEmpty: typeof latitude === 'number' && typeof longitude === 'number',
         });
@@ -98,7 +121,10 @@ export async function handleGs25SearchProducts(c) {
         return errorResponse(c, 'MISSING_QUERY', '검색어(keyword)를 입력해주세요.');
     }
     try {
-        const products = await fetchGs25SearchProducts(keyword, { timeout: 20000 });
+        const products = await fetchGs25SearchProducts(keyword, {
+            timeout: 20000,
+            zyteApiKey: c.env?.ZYTE_API_KEY,
+        });
         const limitedProducts = products.slice(0, limit);
         return successResponse(c, {
             keyword,
@@ -142,7 +168,8 @@ export async function handleGs25CheckInventory(c) {
         return errorResponse(c, 'MISSING_QUERY', '검색어(keyword) 또는 상품 코드(itemCode)를 입력해주세요.');
     }
     try {
-        if ((typeof latitude !== 'number' || typeof longitude !== 'number') && storeKeyword.trim().length > 0) {
+        if ((typeof latitude !== 'number' || typeof longitude !== 'number') &&
+            storeKeyword.trim().length > 0) {
             const directGeocoded = await geocodeGs25Address(storeKeyword, {
                 timeout: 15000,
                 googleMapsApiKey: c.env?.GOOGLE_MAPS_API_KEY,
@@ -157,9 +184,9 @@ export async function handleGs25CheckInventory(c) {
                     serviceCode,
                 }, {
                     timeout: 20000,
+                    zyteApiKey: c.env?.ZYTE_API_KEY,
                 });
-                const firstAddress = filterGs25StoresByKeyword(baseStores.stores, storeKeyword).find((store) => store.address.trim().length > 0)
-                    ?.address || '';
+                const firstAddress = filterGs25StoresByKeyword(baseStores.stores, storeKeyword).find((store) => store.address.trim().length > 0)?.address || '';
                 if (firstAddress.length > 0) {
                     const geocoded = await geocodeGs25Address(firstAddress, {
                         timeout: 15000,
@@ -188,10 +215,14 @@ export async function handleGs25CheckInventory(c) {
                 useCache: false,
             }, {
                 timeout: 20000,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
             });
         }
         else {
-            const searchProducts = await fetchGs25SearchProducts(keyword, { timeout: 20000 });
+            const searchProducts = await fetchGs25SearchProducts(keyword, {
+                timeout: 20000,
+                zyteApiKey: c.env?.ZYTE_API_KEY,
+            });
             firstProduct = searchProducts.find((p) => p.itemCode.length > 0);
             if (firstProduct) {
                 resolvedItemCode = firstProduct.itemCode;
@@ -205,6 +236,7 @@ export async function handleGs25CheckInventory(c) {
                     useCache: false,
                 }, {
                     timeout: 20000,
+                    zyteApiKey: c.env?.ZYTE_API_KEY,
                 });
             }
             else {
@@ -217,6 +249,7 @@ export async function handleGs25CheckInventory(c) {
                     useCache: false,
                 }, {
                     timeout: 20000,
+                    zyteApiKey: c.env?.ZYTE_API_KEY,
                 });
             }
         }
@@ -227,8 +260,10 @@ export async function handleGs25CheckInventory(c) {
         const withDistance = attachDistanceToGs25Stores(filtered, latitude, longitude);
         const stores = sortGs25Stores(withDistance).slice(0, storeLimit);
         // 상품 정보: searchProducts에서 먼저 가져오고, 없으면 stores에서
-        const productName = firstProduct?.itemName || firstProduct?.shortItemName ||
-            filtered.find((item) => item.searchItemName.length > 0)?.searchItemName || null;
+        const productName = firstProduct?.itemName ||
+            firstProduct?.shortItemName ||
+            filtered.find((item) => item.searchItemName.length > 0)?.searchItemName ||
+            null;
         const productPrice = filtered.find((item) => item.searchItemSellPrice !== null)?.searchItemSellPrice ?? null;
         const inStockStoreCount = filtered.filter((item) => item.realStockQuantity > 0).length;
         const totalStockQuantity = filtered.reduce((sum, item) => sum + Math.max(item.realStockQuantity, 0), 0);

package/dist/api/healthChecks.js

@@ -4,8 +4,13 @@
 const HEALTH_CHECK_CACHE_TTL_MS = 60_000;
 const DEFAULT_HEALTH_CHECK_TIMEOUT_MS = 7000;
 const MAX_HEALTH_CHECK_TIMEOUT_MS = 20_000;
-const DEFAULT_HEALTH_CHECK_CONCURRENCY = 6;
+const DEFAULT_HEALTH_CHECK_CONCURRENCY = 1;
 const DEFAULT_HEALTH_CHECK_SLOW_THRESHOLD_MS = 0;
+const GS25_CLOUDFRONT_403_PATTERNS = [
+    '403 Forbidden',
+    'The request could not be satisfied',
+    '403 ERROR',
+];
 const HEALTH_CHECKS = [
     {
         id: 'cli.contract',
@@ -50,6 +55,7 @@ const HEALTH_CHECKS = [
         path: '/api/gs25/products?keyword=%EC%BD%9C%EB%9D%BC&limit=1',
         collectionKey: 'products',
         requiredFields: ['itemCode', 'itemName', 'name'],
+        degradedFailurePatterns: GS25_CLOUDFRONT_403_PATTERNS,
     },
     {
         id: 'gs25.stores',
@@ -86,6 +92,7 @@ const HEALTH_CHECKS = [
         path: '/api/oliveyoung/products?keyword=%EB%A6%BD%EB%B0%A4&size=1',
         collectionKey: 'products',
         requiredFields: ['goodsNumber', 'goodsName', 'productNo', 'productName', 'name'],
+        timeoutMs: 5000,
     },
     {
         id: 'megabox.theaters',
@@ -140,6 +147,11 @@ const HEALTH_CHECKS = [
         path: '/api/gs25/inventory?keyword=%EC%BD%9C%EB%9D%BC&storeKeyword=%EA%B0%95%EB%82%A8&limit=1',
         collectionKey: 'inventoryItems',
         requiredFields: ['itemCode', 'itemName', 'name'],
+        degradedFailurePatterns: [
+            '401 Unauthorized',
+            '인증키가 제공되지 않음',
+            ...GS25_CLOUDFRONT_403_PATTERNS,
+        ],
     },
     {
         id: 'seveneleven.inventory',
@@ -158,6 +170,7 @@ const HEALTH_CHECKS = [
         path: '/api/oliveyoung/inventory?keyword=%EC%84%A0%ED%81%AC%EB%A6%BC&storeKeyword=%EB%AA%85%EB%8F%99&size=1&storeLimit=1&stockCheckLimit=0',
         collectionKey: 'inventoryProducts',
         requiredFields: ['goodsNumber', 'goodsName', 'productNo', 'productName', 'name'],
+        timeoutMs: 5000,
     },
 ];
 const healthCheckCache = new Map();
@@ -322,6 +335,24 @@ function aggregateStatus(checks) {
     }
     return 'ok';
 }
+function shouldDegradeFailedResponse(check, message) {
+    return check.degradedFailurePatterns?.some((pattern) => message.includes(pattern)) ?? false;
+}
+function shouldDegradeCliContractPath(path, message) {
+    return path.startsWith('/api/gs25/') && GS25_CLOUDFRONT_403_PATTERNS.some((pattern) => message.includes(pattern));
+}
+function resolveCheckTimeoutMs(check, timeoutMs) {
+    if (check.timeoutMs === undefined) {
+        return timeoutMs;
+    }
+    return Math.min(timeoutMs, Math.trunc(check.timeoutMs));
+}
+function resolveCliContractTimeoutMs(path, timeoutMs) {
+    if (path.startsWith('/api/oliveyoung/')) {
+        return Math.min(timeoutMs, 5000);
+    }
+    return timeoutMs;
+}
 function buildCheckUrl(baseUrl, check, timeoutMs, cacheBustValue) {
     const url = new URL(check.path, baseUrl);
     url.searchParams.set('timeoutMs', String(timeoutMs));
@@ -357,14 +388,21 @@ function isCliCompatibleEnvelope(path, body) {
 async function runCliContractCheck(check, params) {
     const startedAt = params.now();
     const cacheBustValue = params.cacheBust ? startedAt : undefined;
+    const degradedMessages = [];
     for (const path of CLI_CONTRACT_PATHS) {
+        const checkTimeoutMs = resolveCliContractTimeoutMs(path, params.timeoutMs);
         const syntheticCheck = { ...check, path };
         try {
-            const response = await params.fetchImpl(buildCheckUrl(params.baseUrl, syntheticCheck, params.timeoutMs, cacheBustValue), {
-                signal: AbortSignal.timeout(params.timeoutMs),
+            const response = await params.fetchImpl(buildCheckUrl(params.baseUrl, syntheticCheck, checkTimeoutMs, cacheBustValue), {
+                signal: AbortSignal.timeout(checkTimeoutMs),
             });
             const body = (await response.json().catch(() => ({})));
             if (!response.ok || !isCliCompatibleEnvelope(path, body)) {
+                const message = body.error?.message || `${path} CLI 계약 응답이 올바르지 않습니다.`;
+                if (shouldDegradeCliContractPath(path, message)) {
+                    degradedMessages.push(`${path}: ${message}`);
+                    continue;
+                }
                 return {
                     id: check.id,
                     service: check.service,
@@ -372,7 +410,7 @@ async function runCliContractCheck(check, params) {
                     status: 'fail',
                     durationMs: params.now() - startedAt,
                     httpStatus: response.status,
-                    message: body.error?.message || `${path} CLI 계약 응답이 올바르지 않습니다.`,
+                    message,
                 };
             }
         }
@@ -391,16 +429,18 @@ async function runCliContractCheck(check, params) {
         id: check.id,
         service: check.service,
         target: check.target,
-        status: 'ok',
+        status: degradedMessages.length > 0 ? 'degraded' : 'ok',
         durationMs: params.now() - startedAt,
-        message: `${CLI_CONTRACT_PATHS.length} CLI contract endpoint(s) passed`,
+        message: degradedMessages.length > 0
+            ? `known upstream issue: ${degradedMessages[0]}`
+            : `${CLI_CONTRACT_PATHS.length} CLI contract endpoint(s) passed`,
     };
 }
 async function runSingleCheck(check, params) {
     if (check.kind === 'cli-contract') {
         return runCliContractCheck(check, params);
     }
-    const timeoutMs = params.timeoutMs;
+    const timeoutMs = resolveCheckTimeoutMs(check, params.timeoutMs);
     const startedAt = params.now();
     const cacheBustValue = params.cacheBust ? startedAt : undefined;
     try {
@@ -410,14 +450,15 @@ async function runSingleCheck(check, params) {
         const body = (await response.json().catch(() => ({})));
         const durationMs = params.now() - startedAt;
         if (!response.ok || body.success === false) {
+            const message = body.error?.message || `HTTP ${response.status}`;
             return {
                 id: check.id,
                 service: check.service,
                 target: check.target,
-                status: 'fail',
+                status: shouldDegradeFailedResponse(check, message) ? 'degraded' : 'fail',
                 durationMs,
                 httpStatus: response.status,
-                message: body.error?.message || `HTTP ${response.status}`,
+                message,
             };
         }
         const count = typeof body.meta?.total === 'number' ? body.meta.total : toCount(body.data);

package/dist/api/placesHandlers.js

@@ -0,0 +1,44 @@
+/**
+ * 장소 검색 GET API 핸들러
+ */
+import { errorResponse, successResponse } from './response.js';
+import { searchNaverLocalPlaces } from '../services/places/client.js';
+import { getErrorMessage } from '../core/errors.js';
+const PLACE_CATEGORIES = new Set(['restaurant', 'cafe', 'food', 'dessert', 'all']);
+function parseCategory(value) {
+    if (value && PLACE_CATEGORIES.has(value)) {
+        return value;
+    }
+    return 'all';
+}
+export async function handlePlacesSearch(c) {
+    const location = c.req.query('location') || '';
+    const keyword = c.req.query('keyword') || '';
+    const limit = Number.parseInt(c.req.query('limit') || '5', 10);
+    const start = Number.parseInt(c.req.query('start') || '1', 10);
+    const sort = c.req.query('sort') === 'comment' ? 'comment' : 'random';
+    const category = parseCategory(c.req.query('category'));
+    if (location.trim().length === 0 && keyword.trim().length === 0) {
+        return errorResponse(c, 'MISSING_QUERY', '위치(location) 또는 검색어(keyword)를 입력해주세요.');
+    }
+    try {
+        const result = await searchNaverLocalPlaces({
+            naverClientId: c.env?.NAVER_CLIENT_ID,
+            naverClientSecret: c.env?.NAVER_CLIENT_SECRET,
+            location,
+            keyword,
+            category,
+            limit,
+            start,
+            sort,
+        });
+        return successResponse(c, result, {
+            total: result.totalCount,
+            page: start,
+            pageSize: result.count,
+        });
+    }
+    catch (error) {
+        return errorResponse(c, 'PLACES_SEARCH_FAILED', getErrorMessage(error), 500);
+    }
+}

package/dist/api/routes/healthRoutes.js

@@ -41,7 +41,7 @@ export function registerHealthRoutes(app) {
         const baseUrl = c.req.query('baseUrl')?.trim() || c.env?.HEALTH_CHECK_BASE_URL?.trim() || new URL(c.req.url).origin;
         const transport = c.req.query('transport') || c.env?.HEALTH_CHECK_TRANSPORT || 'internal';
         const cacheBust = parseBoolean(c.req.query('cacheBust')) || transport === 'network';
-        const fetchImpl = c.env?.HEALTH_CHECK_BASE_URL && transport !== 'network'
+        const fetchImpl = transport !== 'network'
             ? async (input, init) => app.fetch(new Request(input, init), c.env)
             : undefined;
         const result = await runHealthChecks({

package/dist/api/routes/placesRoutes.js

@@ -0,0 +1,9 @@
+import { withEdgeCache } from '../../utils/cache.js';
+import { handlePlacesSearch } from '../placesHandlers.js';
+export function registerPlacesRoutes(app) {
+    app.get('/api/places/search', async (c) => withEdgeCache(c.req.url, {
+        ttlSeconds: 60 * 60,
+        staleWhileRevalidateSeconds: 60 * 10,
+        keyPrefix: 'places-search-v1',
+    }, () => handlePlacesSearch(c)));
+}