daiso 1.0.3 → 1.0.5

package/dist/services/cu/client.js

@@ -0,0 +1,297 @@
+/**
+ * CU API 클라이언트
+ */
+import { fetchJson } from '../../utils/http.js';
+import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { CU_API } from './api.js';
+const CU_DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json, text/javascript, */*; q=0.01',
+    'X-Requested-With': 'XMLHttpRequest',
+};
+const CU_WEB_DEFAULT_HEADERS = {
+    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+    'X-Requested-With': 'XMLHttpRequest',
+    Accept: 'text/html, */*; q=0.01',
+    'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
+    Origin: 'https://cu.bgfretail.com',
+    Referer: 'https://cu.bgfretail.com/store/list.do?category=store',
+};
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toYnBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toUpperCase();
+        return normalized === 'Y' || normalized === 'TRUE';
+    }
+    return false;
+}
+function toStoreAddress(raw) {
+    const road = [raw.doroStoreAddr1 || '', raw.doroStoreAddr2 || ''].join(' ').trim();
+    if (road.length > 0) {
+        return road;
+    }
+    return [raw.addrFst || '', raw.addrDetail || ''].join(' ').trim();
+}
+async function requestCuJson(path, body, timeout = 15000) {
+    return fetchJson(`${CU_API.BASE_URL}${path}`, {
+        method: 'POST',
+        timeout,
+        headers: CU_DEFAULT_HEADERS,
+        body: JSON.stringify(body),
+    });
+}
+async function requestCuWebHtml(path, body, apiKey, timeout = 15000) {
+    const form = new URLSearchParams(body);
+    const formText = form.toString();
+    const targetUrl = `${CU_API.WEB_BASE_URL}${path}`;
+    const response = await fetch(`${CU_API.WEB_BASE_URL}${path}`, {
+        method: 'POST',
+        headers: CU_WEB_DEFAULT_HEADERS,
+        body: formText,
+        signal: AbortSignal.timeout(timeout),
+    });
+    if (response.ok) {
+        return response.text();
+    }
+    if (response.status === 400 || response.status === 403 || response.status === 429) {
+        try {
+            const result = await requestByZyte({
+                apiKey,
+                url: targetUrl,
+                timeout,
+                method: 'POST',
+                headers: Object.entries(CU_WEB_DEFAULT_HEADERS).map(([name, value]) => ({ name, value })),
+                bodyText: formText,
+            });
+            if (result.statusCode === 200 && result.httpResponseBody) {
+                return decodeBase64(result.httpResponseBody);
+            }
+        }
+        catch {
+            // 직접 호출 실패 시 Zyte 재시도도 실패하면 원본 에러를 반환합니다.
+        }
+    }
+    throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
+}
+export async function geocodeCuAddress(address, options = {}) {
+    const keyword = address.trim();
+    if (keyword.length === 0) {
+        return null;
+    }
+    const { timeout = 15000, googleMapsApiKey } = options;
+    const apiKey = (googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', keyword);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        return null;
+    }
+    const firstLocation = body.results?.[0]?.geometry?.location;
+    if (!firstLocation) {
+        return null;
+    }
+    const latitude = toNumber(firstLocation.lat);
+    const longitude = toNumber(firstLocation.lng);
+    if (latitude === 0 || longitude === 0) {
+        return null;
+    }
+    return {
+        latitude,
+        longitude,
+    };
+}
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/ /g, ' ')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function sanitizeHtmlText(value) {
+    const stripped = value.replace(/<[^>]*>/g, ' ');
+    return decodeHtmlEntities(stripped).replace(/\s+/g, ' ').trim();
+}
+function parseCuWebStores(html) {
+    const rows = html.match(/<tr>[\s\S]*?<\/tr>/g) || [];
+    const stores = [];
+    for (const row of rows) {
+        const nameMatch = row.match(/<span class="name">([\s\S]*?)<\/span>/);
+        if (!nameMatch) {
+            continue;
+        }
+        const phoneMatch = row.match(/<span class="tel">([\s\S]*?)<\/span>/);
+        const addressMatch = row.match(/<address>[\s\S]*?<a [^>]*>([\s\S]*?)<\/a>/);
+        const codeMatch = row.match(/searchLatLng\('[^']*',\s*'([^']+)'\)/);
+        stores.push({
+            storeCode: codeMatch?.[1] || '',
+            storeName: sanitizeHtmlText(nameMatch[1]),
+            phone: sanitizeHtmlText(phoneMatch?.[1] || ''),
+            address: sanitizeHtmlText(addressMatch?.[1] || ''),
+            latitude: 0,
+            longitude: 0,
+            distanceM: 0,
+            stock: 0,
+            deliveryYn: false,
+            pickupYn: false,
+            reserveYn: false,
+        });
+    }
+    return stores;
+}
+function normalizeCuStore(raw) {
+    return {
+        storeCode: raw.storeCd || '',
+        storeName: raw.storeNm || '',
+        phone: raw.storeTelNo || '',
+        address: toStoreAddress(raw),
+        latitude: toNumber(raw.latVal),
+        longitude: toNumber(raw.longVal),
+        distanceM: toNumber(raw.distance),
+        stock: toNumber(raw.stock),
+        deliveryYn: toYnBoolean(raw.deliveryYn) || toYnBoolean(raw.deliveryPickYn),
+        pickupYn: toYnBoolean(raw.jumpoPickYn),
+        reserveYn: toYnBoolean(raw.reserveYn),
+    };
+}
+/**
+ * 좌표 기반 CU 점포 목록을 조회합니다.
+ */
+export async function fetchCuStores(params, options = {}) {
+    const { timeout = 15000, apiKey } = options;
+    const searchWord = (params.searchWord || '').trim();
+    const hasLatitude = typeof params.latitude === 'number' && Number.isFinite(params.latitude);
+    const hasLongitude = typeof params.longitude === 'number' && Number.isFinite(params.longitude);
+    // 좌표가 없고 검색어가 있으면 웹 매장 검색으로 폴백합니다.
+    if (searchWord.length > 0 && (!hasLatitude || !hasLongitude)) {
+        const html = await requestCuWebHtml(CU_API.WEB_STORE_LIST_PATH, {
+            pageIndex: '1',
+            listType: '',
+            jumpoCode: '',
+            jumpoLotto: '',
+            jumpoToto: '',
+            jumpoCash: '',
+            jumpoHour: '',
+            jumpoCafe: '',
+            jumpoDelivery: '',
+            jumpoBakery: '',
+            jumpoFry: '',
+            jumpoMultiDevice: '',
+            jumpoPosCash: '',
+            jumpoBattery: '',
+            jumpoAdderss: '',
+            jumpoSido: '',
+            jumpoGugun: '',
+            jumpodong: '',
+            searchWord,
+        }, apiKey, timeout);
+        const stores = parseCuWebStores(html);
+        return {
+            totalCount: stores.length,
+            stores,
+        };
+    }
+    const latitude = hasLatitude ? params.latitude : 37.5665;
+    const longitude = hasLongitude ? params.longitude : 126.978;
+    const payload = {
+        latVal: String(latitude),
+        longVal: String(longitude),
+        baseLatVal: String(latitude),
+        baseLongVal: String(longitude),
+        tabId: '2',
+        filterSvcList: [],
+        filterAdtList: [],
+        stockCdcYn: 'N',
+        searchStock: false,
+        pickupType: 'change',
+        getRoute: 'IOS',
+        areaTplNo: '0',
+        childMealPickUpYn: 'N',
+        isCurrentSearch: 'N',
+        pageType: params.pageType || 'search_improve',
+        searchWord,
+        isRecommend: params.isRecommend || '',
+        recommendId: params.recommendId || '',
+        jipCd: params.jipCd || params.itemCd || '',
+        itemCd: params.itemCd || '',
+        item_cd: params.itemCd || '',
+        onItemNo: params.onItemNo || '',
+    };
+    const body = await requestCuJson(CU_API.STORE_PATH, payload, timeout);
+    const stores = (body.storeList || []).map((store) => normalizeCuStore(store));
+    return {
+        totalCount: toNumber(body.totalCnt) || stores.length,
+        stores,
+    };
+}
+/**
+ * 재고 검색 전 초기 화면 데이터를 조회합니다.
+ * 정책 변경 시 사전 호출이 필요한 경우를 대비한 워밍업 요청입니다.
+ */
+export async function primeCuStockDisplay(options = {}) {
+    const { timeout = 15000 } = options;
+    await requestCuJson(CU_API.STOCK_DISPLAY_PATH, {}, timeout);
+}
+/**
+ * CU 상품 재고 검색 결과를 조회합니다.
+ */
+export async function fetchCuStock(params, options = {}) {
+    const { timeout = 15000 } = options;
+    try {
+        await primeCuStockDisplay({ timeout });
+    }
+    catch {
+        // 사전 워밍업 실패는 본 검색으로 재시도합니다.
+    }
+    const payload = {
+        searchWord: params.keyword,
+        prevSearchWord: '',
+        spellModifyUseYn: 'Y',
+        offset: params.offset,
+        limit: params.limit,
+        searchSort: params.searchSort,
+    };
+    const body = await requestCuJson(CU_API.STOCK_MAIN_PATH, payload, timeout);
+    const result = body.data?.stockResult?.result;
+    const rows = result?.rows || [];
+    const items = rows
+        .map((row) => row.fields)
+        .filter((fields) => Boolean(fields))
+        .map((fields) => ({
+        itemCode: fields.item_cd || '',
+        onItemNo: fields.on_item_no || '',
+        itemName: fields.item_nm || '',
+        price: toNumber(fields.hyun_maega),
+        pickupYn: toYnBoolean(fields.pickup_yn),
+        deliveryYn: toYnBoolean(fields.deliv_yn),
+        reserveYn: toYnBoolean(fields.reserv_yn),
+    }));
+    return {
+        totalCount: toNumber(result?.total_count) || items.length,
+        spellModifyYn: body.spellModifyYn || 'N',
+        items,
+    };
+}

package/dist/services/cu/index.js

@@ -0,0 +1,21 @@
+/**
+ * CU 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+const CU_METADATA = {
+    id: 'cu',
+    name: 'CU 편의점',
+    version: '1.0.0',
+    description: 'CU 매장 탐색 및 상품 재고 조회 서비스',
+};
+class CuService {
+    metadata = CU_METADATA;
+    getTools() {
+        return [createFindNearbyStoresTool(), createCheckInventoryTool()];
+    }
+}
+export function createCuService() {
+    return new CuService();
+}
+export * from './types.js';

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,6 +4,8 @@
  * 다이소 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, */*',
@@ -33,3 +35,60 @@ export async function fetchDaisoHtml(url, 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, {
+        ...options,
+        headers: withDaisoHeaders({
+            ...options.headers,
+            Authorization: auth.authorization,
+            'X-DM-UID': auth.dmUid,
+            Cookie: auth.cookie,
+        }),
+    });
+}

package/dist/services/daiso/index.js

@@ -7,6 +7,7 @@ import { createSearchProductsTool } from './tools/searchProducts.js';
 import { createFindStoresTool } from './tools/findStores.js';
 import { createCheckInventoryTool } from './tools/checkInventory.js';
 import { createGetPriceInfoTool } from './tools/getPriceInfo.js';
+import { createGetDisplayLocationTool } from './tools/getDisplayLocation.js';
 /**
  * 다이소 서비스 메타데이터
  */
@@ -27,6 +28,7 @@ class DaisoService {
             createFindStoresTool(),
             createCheckInventoryTool(),
             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',
+    };
+}