daiso 1.0.4 → 1.0.6

package/dist/services/cu/tools/checkInventory.js

@@ -0,0 +1,123 @@
+/**
+ * CU 재고 확인 도구
+ */
+import * as z from 'zod';
+import { fetchCuStock, fetchCuStores, geocodeCuAddress } from '../client.js';
+async function checkInventory(args) {
+    const { keyword, latitude, longitude, storeKeyword = '', size = 20, offset = 0, searchSort = 'recom', storeLimit = 10, timeoutMs = 15000, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const stockResult = await fetchCuStock({
+        keyword,
+        limit: size,
+        offset,
+        searchSort,
+    }, {
+        timeout: timeoutMs,
+    });
+    const firstStockItem = stockResult.items.find((item) => item.itemCode.trim().length > 0) || null;
+    const hasInputLocation = typeof latitude === 'number' && typeof longitude === 'number';
+    const resolvedLatitude = hasInputLocation ? latitude : undefined;
+    const resolvedLongitude = hasInputLocation ? longitude : undefined;
+    let storeResult = null;
+    // 좌표 미입력 + 매장 키워드 입력 시, 키워드 기반 매장 검색 결과를 우선 사용합니다.
+    if (!hasInputLocation && storeKeyword.trim().length > 0) {
+        const keywordStoreResult = await fetchCuStores({
+            searchWord: storeKeyword,
+        }, {
+            timeout: timeoutMs,
+        });
+        const firstAddress = keywordStoreResult.stores.find((store) => store.address.trim().length > 0)?.address || '';
+        if (firstAddress.length > 0) {
+            const googleMapsApiKey = process.env.GOOGLE_MAPS_API_KEY;
+            const geocoded = await geocodeCuAddress(firstAddress, {
+                timeout: timeoutMs,
+                googleMapsApiKey,
+            });
+            if (geocoded) {
+                const hasStockSeed = !!firstStockItem?.itemCode;
+                storeResult = await fetchCuStores({
+                    latitude: geocoded.latitude,
+                    longitude: geocoded.longitude,
+                    searchWord: storeKeyword,
+                    itemCd: firstStockItem?.itemCode || '',
+                    onItemNo: firstStockItem?.onItemNo || '',
+                    jipCd: firstStockItem?.itemCode || '',
+                    isRecommend: hasStockSeed ? 'Y' : '',
+                    recommendId: hasStockSeed ? 'stock' : '',
+                    pageType: hasStockSeed ? 'search_improve stock_sch_improve' : 'search_improve',
+                }, {
+                    timeout: timeoutMs,
+                });
+            }
+        }
+        storeResult ||= keywordStoreResult;
+    }
+    if (!storeResult) {
+        const hasStockSeed = !!firstStockItem?.itemCode;
+        storeResult = await fetchCuStores({
+            latitude: resolvedLatitude,
+            longitude: resolvedLongitude,
+            searchWord: storeKeyword,
+            itemCd: firstStockItem?.itemCode || '',
+            onItemNo: firstStockItem?.onItemNo || '',
+            jipCd: firstStockItem?.itemCode || '',
+            isRecommend: hasStockSeed ? 'Y' : '',
+            recommendId: hasStockSeed ? 'stock' : '',
+            pageType: hasStockSeed ? 'search_improve stock_sch_improve' : 'search_improve',
+        }, {
+            timeout: timeoutMs,
+        });
+    }
+    const limitedStores = storeResult.stores.slice(0, storeLimit);
+    const result = {
+        keyword,
+        searchOptions: {
+            size,
+            offset,
+            searchSort,
+            storeKeyword,
+        },
+        location: typeof resolvedLatitude === 'number' && typeof resolvedLongitude === 'number'
+            ? { latitude: resolvedLatitude, longitude: resolvedLongitude }
+            : null,
+        nearbyStores: {
+            totalCount: storeResult.totalCount,
+            count: limitedStores.length,
+            stockItemCode: firstStockItem?.itemCode || null,
+            stockItemName: firstStockItem?.itemName || null,
+            stores: limitedStores,
+        },
+        inventory: {
+            totalCount: stockResult.totalCount,
+            count: stockResult.items.length,
+            spellModifyYn: stockResult.spellModifyYn,
+            items: stockResult.items,
+        },
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createCheckInventoryTool() {
+    return {
+        name: 'cu_check_inventory',
+        metadata: {
+            title: 'CU 재고 확인',
+            description: '상품 키워드로 CU 재고를 조회하고 주변 매장 정보를 함께 반환합니다.',
+            inputSchema: {
+                keyword: z.string().describe('재고를 확인할 상품 검색어 (예: 과자, 커피, 도시락)'),
+                latitude: z.number().optional().describe('위도 (없으면 storeKeyword 기반으로 좌표 추정 시도)'),
+                longitude: z.number().optional().describe('경도 (없으면 storeKeyword 기반으로 좌표 추정 시도)'),
+                storeKeyword: z.string().optional().describe('주변 매장 필터 키워드 (예: 강남, 안산)'),
+                size: z.number().optional().default(20).describe('재고 검색 결과 수 (기본값: 20)'),
+                offset: z.number().optional().default(0).describe('재고 검색 시작 오프셋 (기본값: 0)'),
+                searchSort: z.string().optional().default('recom').describe('재고 정렬 방식 (기본값: recom)'),
+                storeLimit: z.number().optional().default(10).describe('반환할 주변 매장 최대 수 (기본값: 10)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: checkInventory,
+    };
+}

package/dist/services/cu/tools/findNearbyStores.js

@@ -0,0 +1,49 @@
+/**
+ * CU 주변 매장 탐색 도구
+ */
+import * as z from 'zod';
+import { fetchCuStores } from '../client.js';
+async function findNearbyStores(args) {
+    const { latitude, longitude, keyword = '', limit = 20, timeoutMs = 15000, } = args;
+    const { totalCount, stores } = await fetchCuStores({
+        latitude,
+        longitude,
+        searchWord: keyword,
+    }, {
+        timeout: timeoutMs,
+    });
+    const limitedStores = stores.slice(0, limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    location: typeof latitude === 'number' && typeof longitude === 'number'
+                        ? { latitude, longitude }
+                        : null,
+                    keyword,
+                    totalCount,
+                    count: limitedStores.length,
+                    stores: limitedStores,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createFindNearbyStoresTool() {
+    return {
+        name: 'cu_find_nearby_stores',
+        metadata: {
+            title: 'CU 주변 매장 탐색',
+            description: '위치(위도/경도)와 키워드로 CU 매장을 검색합니다.',
+            inputSchema: {
+                latitude: z.number().optional().describe('위도 (없으면 키워드 기반 검색)'),
+                longitude: z.number().optional().describe('경도 (없으면 키워드 기반 검색)'),
+                keyword: z.string().optional().describe('매장 검색 키워드 (예: 강남, 명동, 안산)'),
+                limit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: findNearbyStores,
+    };
+}

package/dist/services/cu/types.js

@@ -0,0 +1,4 @@
+/**
+ * CU 서비스 전용 타입 정의
+ */
+export {};

package/dist/services/daiso/api.js

@@ -12,10 +12,18 @@ export const DAISOMALL_API = {
     SEARCH_PRODUCTS: 'https://prdm.daisomall.co.kr/ssn/search/FindStoreGoods',
     /** 온라인 재고 조회 API */
     ONLINE_STOCK: 'https://mapi.daisomall.co.kr/ms/msg/selOnlStck',
-    /** 매장별 재고 조회 API */
+    /** 구 재고 조회 API (현재 403 Unauthorized 발생) */
     STORE_INVENTORY: 'https://mapi.daisomall.co.kr/ms/msg/newIntSelStr',
+    /** 현재 사용 중인 인증 토큰 요청 API */
+    AUTH_REQUEST: 'https://fapi.daisomall.co.kr/auth/request',
+    /** 현재 사용 중인 위치 기반 매장 조회 API */
+    STORE_SEARCH_V2: 'https://fapi.daisomall.co.kr/ms/msg/selStr',
+    /** 현재 사용 중인 매장별 재고 조회 API */
+    STORE_INVENTORY_V2: 'https://fapi.daisomall.co.kr/pd/pdh/selStrPkupStck',
+    /** 매장 내 상품 진열 위치 조회 API */
+    DISPLAY_LOCATION: 'https://fapi.daisomall.co.kr/pdo/selIntPdStDispInfo',
     /** 이미지 CDN 베이스 URL */
-    IMAGE_BASE_URL: 'https://img.daisomall.co.kr',
+    IMAGE_BASE_URL: 'https://cdn.daisomall.co.kr',
 };
 /**
  * 다이소 공식 사이트 API (daiso.co.kr)
@@ -37,6 +45,18 @@ export const DAISO_WEB_API = {
 export function getImageUrl(path) {
     if (!path)
         return undefined;
+    if (path.startsWith('http://') || path.startsWith('https://')) {
+        try {
+            const url = new URL(path);
+            if (url.hostname === 'img.daisomall.co.kr') {
+                url.hostname = 'cdn.daisomall.co.kr';
+            }
+            return url.toString();
+        }
+        catch {
+            return path;
+        }
+    }
     return `${DAISOMALL_API.IMAGE_BASE_URL}${path}`;
 }
 /**

package/dist/services/daiso/client.js

@@ -4,11 +4,17 @@
  * 다이소 API 호출 시 필요한 기본 헤더를 적용합니다.
  */
 import { fetchJson, fetchText, fetchWithTimeout } from '../../utils/http.js';
+import { DAISOMALL_API } from './api.js';
+const DAISO_AUTH_KEY = 'PRE_AUTH_ENC_KEY';
 const DAISO_DEFAULT_HEADERS = {
     'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
     Accept: 'application/json, text/html, */*',
     'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
 };
+const DAISO_DEFAULT_FETCH_OPTIONS = {
+    retries: 1,
+    retryDelayMs: 250,
+};
 function withDaisoHeaders(headers = {}) {
     return {
         ...DAISO_DEFAULT_HEADERS,
@@ -17,19 +23,80 @@ function withDaisoHeaders(headers = {}) {
 }
 export async function daisoFetch(url, options = {}) {
     return fetchWithTimeout(url, {
+        ...DAISO_DEFAULT_FETCH_OPTIONS,
         ...options,
         headers: withDaisoHeaders(options.headers),
     });
 }
 export async function fetchDaisoJson(url, options = {}) {
     return fetchJson(url, {
+        ...DAISO_DEFAULT_FETCH_OPTIONS,
         ...options,
         headers: withDaisoHeaders(options.headers),
     });
 }
 export async function fetchDaisoHtml(url, options = {}) {
     return fetchText(url, {
+        ...DAISO_DEFAULT_FETCH_OPTIONS,
         ...options,
         headers: withDaisoHeaders(options.headers),
     });
 }
+function base64FromBytes(bytes) {
+    /* c8 ignore next -- Node 20 CI always provides Buffer; the fallback below is for browser-like runtimes. */
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    /* c8 ignore start -- Node 20 CI always provides Buffer; this fallback is for browser-like runtimes. */
+    let binary = '';
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    if (typeof btoa === 'function') {
+        return btoa(binary);
+    }
+    throw new Error('Base64 인코딩을 지원하지 않는 환경입니다.');
+    /* c8 ignore stop */
+}
+async function createDaisoAuthHeader(token) {
+    const encoder = new TextEncoder();
+    const iv = crypto.getRandomValues(new Uint8Array(16));
+    const key = await crypto.subtle.importKey('raw', encoder.encode(DAISO_AUTH_KEY), { name: 'AES-CBC' }, false, ['encrypt']);
+    const encrypted = await crypto.subtle.encrypt({ name: 'AES-CBC', iv }, key, encoder.encode(token));
+    return `${base64FromBytes(iv)}${base64FromBytes(new Uint8Array(encrypted))}`;
+}
+export async function createDaisoAuthContext() {
+    const response = await daisoFetch(DAISOMALL_API.AUTH_REQUEST, {
+        method: 'GET',
+    });
+    if (!response.ok) {
+        throw new Error(`다이소 인증 토큰 요청 실패: ${response.status} ${response.statusText}`);
+    }
+    const token = (await response.text()).trim();
+    const dmUid = response.headers.get('x-dm-uid')?.trim() || '';
+    if (!token) {
+        throw new Error('다이소 인증 토큰이 비어 있습니다.');
+    }
+    if (!dmUid) {
+        throw new Error('다이소 인증 응답에 X-DM-UID 헤더가 없습니다.');
+    }
+    const authorization = await createDaisoAuthHeader(token);
+    return {
+        authorization: `Bearer ${authorization}`,
+        dmUid,
+        cookie: `DM_UID=${dmUid}`,
+    };
+}
+export async function fetchDaisoJsonWithAuth(url, options = {}) {
+    const auth = await createDaisoAuthContext();
+    return fetchJson(url, {
+        ...DAISO_DEFAULT_FETCH_OPTIONS,
+        ...options,
+        headers: withDaisoHeaders({
+            ...options.headers,
+            Authorization: auth.authorization,
+            'X-DM-UID': auth.dmUid,
+            Cookie: auth.cookie,
+        }),
+    });
+}

package/dist/services/daiso/index.js

@@ -6,7 +6,9 @@
 import { createSearchProductsTool } from './tools/searchProducts.js';
 import { createFindStoresTool } from './tools/findStores.js';
 import { createCheckInventoryTool } from './tools/checkInventory.js';
+import { createFindInventoryByNameTool } from './tools/findInventoryByName.js';
 import { createGetPriceInfoTool } from './tools/getPriceInfo.js';
+import { createGetDisplayLocationTool } from './tools/getDisplayLocation.js';
 /**
  * 다이소 서비스 메타데이터
  */
@@ -26,7 +28,9 @@ class DaisoService {
             createSearchProductsTool(),
             createFindStoresTool(),
             createCheckInventoryTool(),
+            createFindInventoryByNameTool(),
             createGetPriceInfoTool(),
+            createGetDisplayLocationTool(),
         ];
     }
 }

package/dist/services/daiso/product.js

@@ -0,0 +1,17 @@
+/**
+ * 다이소 상품 매핑 유틸리티
+ */
+import { getImageUrl } from './api.js';
+/**
+ * 검색/상세 응답의 상품 문서를 공통 요약 형태로 변환합니다.
+ */
+export function toProductSummary(product) {
+    return {
+        id: product.PD_NO,
+        name: product.PDNM || product.EXH_PD_NM || '',
+        imageUrl: getImageUrl(product.ATCH_FILE_URL),
+        brand: product.BRND_NM || undefined,
+        soldOut: product.SOLD_OUT_YN === 'Y',
+        isNew: product.NEW_PD_YN === 'Y',
+    };
+}

package/dist/services/daiso/tools/checkInventory.js

@@ -5,7 +5,23 @@
  */
 import * as z from 'zod';
 import { DAISOMALL_API } from '../api.js';
-import { fetchDaisoJson } from '../client.js';
+import { fetchDaisoJson, fetchDaisoJsonWithAuth } from '../client.js';
+import { buildDaisoStoreKeywordVariants } from '../../../utils/daisoKeyword.js';
+import { fetchProductById } from './getPriceInfo.js';
+import { toProductSummary } from '../product.js';
+/**
+ * 재고 응답에 함께 노출할 상품 요약 정보를 조회합니다.
+ * 부가 정보이므로 실패해도 전체 재고 조회는 계속 진행합니다.
+ */
+async function fetchInventoryProduct(productId) {
+    try {
+        const product = await fetchProductById(productId);
+        return product ? toProductSummary(product) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * 온라인 재고 조회
  */
@@ -24,46 +40,63 @@ export async function fetchOnlineStock(productNo) {
  * 매장별 재고 조회
  */
 export async function fetchStoreInventory(productNo, lat, lng, page = 1, pageSize = 30, keyword = '') {
-    const data = await fetchDaisoJson(DAISOMALL_API.STORE_INVENTORY, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            keyword,
-            pdNo: productNo,
-            curLttd: lat,
-            curLitd: lng,
-            geolocationAgrYn: 'Y',
-            pkupYn: '',
-            intCd: '',
-            pageSize,
-            currentPage: page,
-        }),
-    });
-    if (!data.success || !data.data?.msStrVOList) {
-        return { stores: [], totalCount: 0 };
+    const searchKeywords = keyword ? buildDaisoStoreKeywordVariants(keyword) : [''];
+    for (const searchKeyword of searchKeywords) {
+        const storeSearch = await fetchDaisoJson(DAISOMALL_API.STORE_SEARCH_V2, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                inclusiveStrCd: '',
+                keyword: searchKeyword,
+                curLttd: lat,
+                curLitd: lng,
+            }),
+        });
+        const allStores = storeSearch.data || [];
+        const searchedStores = allStores.slice((page - 1) * pageSize, page * pageSize);
+        if (searchedStores.length === 0) {
+            if (searchKeyword === searchKeywords[searchKeywords.length - 1]) {
+                return { stores: [], totalCount: 0 };
+            }
+            continue;
+        }
+        const inventoryResponse = await fetchDaisoJsonWithAuth(DAISOMALL_API.STORE_INVENTORY_V2, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(searchedStores.map((store) => ({
+                pdNo: productNo,
+                strCd: store.strCd,
+            }))),
+        });
+        const quantities = new Map((inventoryResponse.data || []).map((item) => [item.strCd, parseInt(item.stck) || 0]));
+        const stores = searchedStores.map((store) => ({
+            storeCode: store.strCd,
+            storeName: store.strNm,
+            address: store.strAddr,
+            phone: store.strTno,
+            openTime: store.opngTime,
+            closeTime: store.clsngTime,
+            lat: store.strLttd,
+            lng: store.strLitd,
+            distance: store.km,
+            quantity: quantities.get(store.strCd) ?? 0,
+            options: {
+                parking: store.parkYn === 'Y',
+                simCard: store.usimYn === 'Y',
+                pickup: store.pkupYn === 'Y',
+                taxFree: store.taxfYn === 'Y',
+                elevator: store.elvtYn === 'Y',
+                ramp: store.entrRampYn === 'Y',
+                cashless: store.nocashYn === 'Y',
+            },
+        }));
+        return {
+            stores,
+            totalCount: allStores.length,
+        };
     }
-    const stores = data.data.msStrVOList.map((store) => ({
-        storeCode: store.strCd,
-        storeName: store.strNm,
-        address: store.strAddr,
-        phone: store.strTno,
-        openTime: store.opngTime,
-        closeTime: store.clsngTime,
-        lat: store.strLttd,
-        lng: store.strLitd,
-        distance: store.km,
-        quantity: parseInt(store.qty) || 0,
-        options: {
-            parking: store.parkYn === 'Y',
-            simCard: store.usimYn === 'Y',
-            pickup: store.pkupYn === 'Y',
-            taxFree: store.taxfYn === 'Y',
-            elevator: store.elvtYn === 'Y',
-            ramp: store.entrRampYn === 'Y',
-            cashless: store.nocashYn === 'Y',
-        },
-    }));
-    return { stores, totalCount: data.data.intStrCont || stores.length };
+    /* c8 ignore next -- searchKeywords is always non-empty; this is a defensive fallback. */
+    return { stores: [], totalCount: 0 };
 }
 /**
  * 재고 확인 핸들러
@@ -75,15 +108,17 @@ async function checkInventory(args) {
         throw new Error('상품 ID(productId)를 입력해주세요.');
     }
     // 온라인 재고와 매장 재고 동시 조회
-    const [onlineStock, storeResult] = await Promise.all([
+    const [onlineStock, storeResult, product] = await Promise.all([
         fetchOnlineStock(productId),
         fetchStoreInventory(productId, latitude, longitude, page, pageSize, storeQuery),
+        fetchInventoryProduct(productId),
     ]);
     // 재고 있는 매장과 없는 매장 분류
     const inStockStores = storeResult.stores.filter((s) => s.quantity > 0);
     const outOfStockStores = storeResult.stores.filter((s) => s.quantity === 0);
     const result = {
         productId,
+        product,
         location: { latitude, longitude },
         onlineStock,
         storeInventory: {
@@ -107,9 +142,11 @@ export function createCheckInventoryTool() {
         name: 'daiso_check_inventory',
         metadata: {
             title: '재고 확인',
-            description: '특정 제품의 매장별 재고를 확인합니다. 매장명/주소 검색 또는 위치 기반으로 조회합니다.',
+            description: '특정 제품의 매장별 재고를 확인합니다. 상품명만 아는 경우 daiso_search_products로 후보를 먼저 찾은 뒤 productId를 전달하세요. 매장명/주소 검색 또는 위치 기반으로 조회합니다. "근처/주변"처럼 위치가 모호하면 storeQuery, latitude/longitude 또는 사용자 위치를 먼저 확인하세요.',
             inputSchema: {
-                productId: z.string().describe('제품 ID (daiso_search_products로 조회한 상품의 id)'),
+                productId: z
+                    .string()
+                    .describe('제품 ID. 상품명만 알면 먼저 daiso_search_products로 상품의 id를 확인하세요.'),
                 storeQuery: z.string().optional().describe('매장 검색어 (매장명 또는 주소, 예: 안산 중앙역)'),
                 latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
                 longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),