daiso 1.0.6 → 1.0.7

package/dist/services/oliveyoung/client.js

@@ -10,6 +10,8 @@ const OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS = 10 * 60 * 1000;
 const OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS = 30 * 60 * 1000;
 const oliveyoungProductIdCache = new Map();
 const oliveyoungProductSearchCache = new Map();
+const oliveyoungStoreSearchCache = new Map();
+const oliveyoungStockStoresCache = new Map();
 const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
 function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
     return o2oStockFlag || o2oRemainQuantity > 0;
@@ -67,6 +69,12 @@ function resolveOliveyoungStoreStock(rawStore) {
 function createOliveyoungProductSearchCacheKey(params) {
     return JSON.stringify([params.keyword, params.page, params.size, params.sort, params.includeSoldOut]);
 }
+function createOliveyoungStoreSearchCacheKey(params) {
+    return JSON.stringify([params.latitude, params.longitude, params.pageIdx, params.searchWords]);
+}
+function createOliveyoungStockStoresCacheKey(params) {
+    return JSON.stringify([params.productId, params.latitude, params.longitude, params.pageIdx, params.searchWords]);
+}
 function cloneOliveyoungProductSearchResult(result) {
     return {
         totalCount: result.totalCount,
@@ -74,17 +82,32 @@ function cloneOliveyoungProductSearchResult(result) {
         products: result.products.map((product) => ({ ...product })),
     };
 }
-function readStaleOliveyoungProductSearchResult(cacheKey) {
-    const cached = oliveyoungProductSearchCache.get(cacheKey);
+function cloneOliveyoungStoreSearchResult(result) {
+    return {
+        totalCount: result.totalCount,
+        stores: result.stores.map((store) => ({ ...store })),
+    };
+}
+function cloneOliveyoungStockStoresResult(result) {
+    return {
+        totalCount: result.totalCount,
+        inStockCount: result.inStockCount,
+        outOfStockCount: result.outOfStockCount,
+        notSoldCount: result.notSoldCount,
+        stores: result.stores.map((store) => ({ ...store })),
+    };
+}
+function readStaleResult(cache, cacheKey, cloneResult) {
+    const cached = cache.get(cacheKey);
     if (!cached || cached.expiresAt <= Date.now()) {
         return null;
     }
-    return cloneOliveyoungProductSearchResult(cached.result);
+    return cloneResult(cached.result);
 }
-function writeStaleOliveyoungProductSearchResult(cacheKey, result) {
-    oliveyoungProductSearchCache.set(cacheKey, {
+function writeStaleResult(cache, cacheKey, result, cloneResult) {
+    cache.set(cacheKey, {
         expiresAt: Date.now() + OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS,
-        result: cloneOliveyoungProductSearchResult(result),
+        result: cloneResult(result),
     });
 }
 async function zyteExtract(targetPath, requestBody, options = {}) {
@@ -130,20 +153,32 @@ export async function fetchOliveyoungStores(params, options = {}) {
         mapLat: params.latitude,
         mapLon: params.longitude,
     };
-    const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
-    const stores = (body.data?.storeList || []).map((store) => ({
-        storeCode: store.storeCode || '',
-        storeName: store.storeName || '',
-        address: store.address || '',
-        latitude: store.latitude || 0,
-        longitude: store.longitude || 0,
-        pickupYn: Boolean(store.pickupYn),
-        o2oRemainQuantity: store.o2oRemainQuantity || 0,
-    }));
-    return {
-        totalCount: body.data?.totalCount || 0,
-        stores,
-    };
+    const cacheKey = createOliveyoungStoreSearchCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
+        const stores = (body.data?.storeList || []).map((store) => ({
+            storeCode: store.storeCode || '',
+            storeName: store.storeName || '',
+            address: store.address || '',
+            latitude: store.latitude || 0,
+            longitude: store.longitude || 0,
+            pickupYn: Boolean(store.pickupYn),
+            o2oRemainQuantity: store.o2oRemainQuantity || 0,
+        }));
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            stores,
+        };
+        writeStaleResult(oliveyoungStoreSearchCache, cacheKey, result, cloneOliveyoungStoreSearchResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungStoreSearchCache, cacheKey, cloneOliveyoungStoreSearchResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 export async function fetchOliveyoungProducts(params, options = {}) {
     const payload = {
@@ -182,11 +217,11 @@ export async function fetchOliveyoungProducts(params, options = {}) {
             nextPage: Boolean(body.data?.nextPage),
             products,
         };
-        writeStaleOliveyoungProductSearchResult(cacheKey, result);
+        writeStaleResult(oliveyoungProductSearchCache, cacheKey, result, cloneOliveyoungProductSearchResult);
         return result;
     }
     catch (error) {
-        const staleResult = readStaleOliveyoungProductSearchResult(cacheKey);
+        const staleResult = readStaleResult(oliveyoungProductSearchCache, cacheKey, cloneOliveyoungProductSearchResult);
         if (staleResult) {
             return staleResult;
         }
@@ -214,25 +249,37 @@ async function fetchOliveyoungProductId(goodsNumber, options = {}) {
     return productId;
 }
 async function fetchOliveyoungStockStores(params, options = {}) {
-    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
-        productId: params.productId,
-        lat: params.latitude,
-        lon: params.longitude,
-        pageIdx: params.pageIdx,
-        searchWords: params.searchWords,
-        mapLat: params.latitude,
-        mapLon: params.longitude,
-    }, options);
-    const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
-    const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
-    const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
-    return {
-        totalCount: body.data?.totalCount || 0,
-        inStockCount,
-        outOfStockCount: stores.length - inStockCount - notSoldCount,
-        notSoldCount,
-        stores,
-    };
+    const cacheKey = createOliveyoungStockStoresCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
+            productId: params.productId,
+            lat: params.latitude,
+            lon: params.longitude,
+            pageIdx: params.pageIdx,
+            searchWords: params.searchWords,
+            mapLat: params.latitude,
+            mapLon: params.longitude,
+        }, options);
+        const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
+        const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
+        const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            inStockCount,
+            outOfStockCount: stores.length - inStockCount - notSoldCount,
+            notSoldCount,
+            stores,
+        };
+        writeStaleResult(oliveyoungStockStoresCache, cacheKey, result, cloneOliveyoungStockStoresResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungStockStoresCache, cacheKey, cloneOliveyoungStockStoresResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 function sortOliveyoungProducts(products) {
     const score = (product) => {
@@ -299,4 +346,6 @@ export async function enrichOliveyoungProductsWithNearbyStoreInventory(products,
 export function __testOnlyClearOliveyoungCaches() {
     oliveyoungProductIdCache.clear();
     oliveyoungProductSearchCache.clear();
+    oliveyoungStoreSearchCache.clear();
+    oliveyoungStockStoresCache.clear();
 }

package/dist/services/places/client.js

@@ -0,0 +1,116 @@
+const CATEGORY_KEYWORDS = {
+    restaurant: '음식점',
+    cafe: '카페',
+    food: '음식점',
+    dessert: '디저트',
+    all: '',
+};
+function getProcessEnvValue(name) {
+    /* c8 ignore next -- Node 테스트와 CLI 런타임은 process를 제공하며, Worker에는 API에서 키를 주입합니다. */
+    return typeof process !== 'undefined' ? process.env[name] : undefined;
+}
+function cleanHtml(value) {
+    if (!value) {
+        return '';
+    }
+    return value
+        .replace(/<[^>]*>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+}
+function toCoordinate(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return parsed / 10000000;
+}
+function clampDisplay(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return 5;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 5);
+}
+function clampStart(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return 1;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 1000);
+}
+export function buildNaverLocalQuery({ location = '', keyword = '', category = 'all', }) {
+    const parts = [location.trim(), keyword.trim() || CATEGORY_KEYWORDS[category]].filter((part) => part.length > 0);
+    return parts.join(' ').trim();
+}
+function normalizePlace(item) {
+    return {
+        name: cleanHtml(item.title),
+        category: cleanHtml(item.category),
+        address: cleanHtml(item.address),
+        roadAddress: cleanHtml(item.roadAddress),
+        phone: cleanHtml(item.telephone),
+        link: item.link,
+        longitude: toCoordinate(item.mapx),
+        latitude: toCoordinate(item.mapy),
+        raw: item,
+    };
+}
+export async function searchNaverLocalPlaces(args) {
+    const naverClientId = args.naverClientId?.trim() || getProcessEnvValue('NAVER_CLIENT_ID')?.trim();
+    const naverClientSecret = args.naverClientSecret?.trim() || getProcessEnvValue('NAVER_CLIENT_SECRET')?.trim();
+    if (!naverClientId || !naverClientSecret) {
+        throw new Error('NAVER_CLIENT_ID와 NAVER_CLIENT_SECRET 환경 변수가 필요합니다.');
+    }
+    const category = args.category ?? 'all';
+    const location = args.location?.trim() ?? '';
+    const query = buildNaverLocalQuery({
+        location,
+        keyword: args.keyword,
+        category,
+    });
+    if (query.length === 0) {
+        throw new Error('위치(location) 또는 검색어(keyword)를 입력해주세요.');
+    }
+    const url = new URL('https://openapi.naver.com/v1/search/local.json');
+    url.searchParams.set('query', query);
+    url.searchParams.set('display', String(clampDisplay(args.limit)));
+    url.searchParams.set('start', String(clampStart(args.start)));
+    url.searchParams.set('sort', args.sort ?? 'random');
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const response = await fetchImpl(url.toString(), {
+        headers: {
+            'X-Naver-Client-Id': naverClientId,
+            'X-Naver-Client-Secret': naverClientSecret,
+        },
+        signal: AbortSignal.timeout(args.timeoutMs ?? 10000),
+    });
+    const bodyText = await response.text();
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        parsed = {};
+    }
+    if (!response.ok) {
+        const message = parsed.errorMessage || bodyText || `HTTP ${response.status}`;
+        throw new Error(`네이버 지역 검색 실패: ${message}`);
+    }
+    const places = (parsed.items ?? []).map(normalizePlace);
+    return {
+        provider: 'naverLocal',
+        searchMode: 'keyword',
+        query,
+        category,
+        location,
+        totalCount: parsed.total ?? places.length,
+        count: places.length,
+        places,
+    };
+}

package/dist/services/places/index.js

@@ -0,0 +1,23 @@
+import { createSearchNearbyPlacesTool } from './tools/searchNearby.js';
+const PLACES_METADATA = {
+    id: 'places',
+    name: '장소 검색',
+    version: '1.0.0',
+    description: '네이버 지역 검색 기반 음식점, 카페, 주변 장소 탐색 서비스',
+};
+class PlacesService {
+    options;
+    metadata = PLACES_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getTools() {
+        return [
+            createSearchNearbyPlacesTool(this.options.naverClientId, this.options.naverClientSecret),
+        ];
+    }
+}
+export function createPlacesService(options = {}) {
+    return new PlacesService(options);
+}
+export * from './types.js';

package/dist/services/places/tools/searchNearby.js

@@ -0,0 +1,56 @@
+/**
+ * 네이버 지역 검색 기반 주변 장소 탐색 도구
+ */
+import * as z from 'zod';
+import { searchNaverLocalPlaces } from '../client.js';
+async function searchNearbyPlaces(args) {
+    const result = await searchNaverLocalPlaces(args);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+        structuredContent: result,
+    };
+}
+export function createSearchNearbyPlacesTool(naverClientId, naverClientSecret) {
+    return {
+        name: 'places_search_nearby',
+        metadata: {
+            title: '주변 음식점/카페 검색',
+            description: '네이버 지역 검색으로 특정 지역의 음식점, 카페, 디저트 가게 등 주변 장소를 키워드 기반으로 찾습니다.',
+            inputSchema: {
+                location: z.string().optional().describe('지역/역/주소 키워드 (예: 강남역, 성수동)'),
+                keyword: z.string().optional().describe('검색어 (예: 라멘, 브런치, 조용한 카페)'),
+                category: z
+                    .enum(['restaurant', 'cafe', 'food', 'dessert', 'all'])
+                    .optional()
+                    .default('all')
+                    .describe('장소 카테고리. restaurant/food=음식점, cafe=카페, dessert=디저트'),
+                limit: z
+                    .number()
+                    .optional()
+                    .default(5)
+                    .describe('반환할 최대 장소 수 (네이버 지역 검색 최대 5)'),
+                start: z.number().optional().default(1).describe('검색 시작 위치 (기본값: 1)'),
+                sort: z
+                    .enum(['random', 'comment'])
+                    .optional()
+                    .default('random')
+                    .describe('정렬 방식. random=유사도순, comment=리뷰순'),
+                timeoutMs: z
+                    .number()
+                    .optional()
+                    .default(10000)
+                    .describe('요청 제한 시간(ms, 기본값: 10000)'),
+            },
+        },
+        handler: ((args) => searchNearbyPlaces({
+            ...args,
+            naverClientId: args.naverClientId || naverClientId,
+            naverClientSecret: args.naverClientSecret || naverClientSecret,
+        })),
+    };
+}

package/dist/services/places/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/zyte.js

@@ -40,6 +40,17 @@ export function decodeBase64(value) {
 function isAbortError(error) {
     return error instanceof Error && error.name === 'AbortError';
 }
+class RetryableZyteError extends Error {
+}
+function isRetryableZyteStatus(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+function isRetryableTargetStatus(statusCode) {
+    return typeof statusCode === 'number' && statusCode >= 500;
+}
+function isRetryableError(error) {
+    return isAbortError(error) || error instanceof RetryableZyteError;
+}
 function wait(ms) {
     if (ms <= 0) {
         return Promise.resolve();
@@ -55,30 +66,46 @@ export async function requestByZyte(options) {
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         const { controller, timeoutId } = createTimeoutController(timeout);
         try {
-            const response = await fetch('https://api.zyte.com/v1/extract', {
-                method: 'POST',
-                headers: {
-                    Authorization: `Basic ${auth}`,
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json',
-                },
-                body: JSON.stringify({
-                    url,
-                    httpRequestMethod: method,
-                    customHttpRequestHeaders: headers,
-                    httpRequestText: bodyText,
-                    httpResponseBody: true,
-                }),
-                signal: controller.signal,
-            });
+            let response;
+            try {
+                response = await fetch('https://api.zyte.com/v1/extract', {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Basic ${auth}`,
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                    },
+                    body: JSON.stringify({
+                        url,
+                        httpRequestMethod: method,
+                        customHttpRequestHeaders: headers,
+                        httpRequestText: bodyText,
+                        httpResponseBody: true,
+                    }),
+                    signal: controller.signal,
+                });
+            }
+            catch (error) {
+                if (error instanceof TypeError) {
+                    throw new RetryableZyteError(error.message);
+                }
+                throw error;
+            }
             const result = (await response.json());
             if (!response.ok) {
-                throw new Error(`Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim());
+                const message = `Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim();
+                if (isRetryableZyteStatus(response.status)) {
+                    throw new RetryableZyteError(message);
+                }
+                throw new Error(message);
+            }
+            if (isRetryableTargetStatus(result.statusCode) && attempt < maxAttempts) {
+                throw new RetryableZyteError(`Zyte target response failed: ${result.statusCode}`);
             }
             return result;
         }
         catch (error) {
-            if (!isAbortError(error) || attempt >= maxAttempts) {
+            if (!isRetryableError(error) || attempt >= maxAttempts) {
                 throw error;
             }
             await wait(retryDelayMs);

package/openapi.json

@@ -53,6 +53,7 @@
                 "sevenelevenCheckInventory",
                 "sevenelevenGetPopwords",
                 "sevenelevenGetCatalog",
+                "placesSearchNearby",
                 "megaboxFindTheaters",
                 "megaboxListMovies",
                 "megaboxGetSeats",
@@ -110,6 +111,24 @@
               "type": "string"
             }
           },
+          {
+            "name": "location",
+            "in": "query",
+            "required": false,
+            "description": "주변 장소 검색 지역/역/주소 키워드",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "category",
+            "in": "query",
+            "required": false,
+            "description": "주변 장소 카테고리(restaurant, cafe, food, dessert, all)",
+            "schema": {
+              "type": "string"
+            }
+          },
           {
             "name": "sido",
             "in": "query",

package/openapi.yaml

@@ -54,6 +54,7 @@ paths:
               - sevenelevenCheckInventory
               - sevenelevenGetPopwords
               - sevenelevenGetCatalog
+              - placesSearchNearby
               - megaboxFindTheaters
               - megaboxListMovies
               - megaboxGetSeats
@@ -93,6 +94,18 @@ paths:
           description: 공통 키워드 파라미터
           schema:
             type: string
+        - name: location
+          in: query
+          required: false
+          description: 주변 장소 검색 지역/역/주소 키워드
+          schema:
+            type: string
+        - name: category
+          in: query
+          required: false
+          description: 주변 장소 카테고리(restaurant, cafe, food, dessert, all)
+          schema:
+            type: string
         - name: sido
           in: query
           required: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "daiso",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Korean retail and cinema MCP server, CLI, and Codex Skill for Daiso, convenience stores, marts, Olive Young, and theaters",
   "main": "dist/index.js",
   "bin": {
@@ -100,7 +100,8 @@
   "overrides": {
     "flatted": "3.4.2",
     "undici": "7.24.0",
-    "brace-expansion": "5.0.6"
+    "brace-expansion": "5.0.6",
+    "ws": "8.20.1"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",