daiso 1.0.0

package/dist/services/oliveyoung/api.js

@@ -0,0 +1,8 @@
+/**
+ * 올리브영 API 엔드포인트 중앙 관리
+ */
+export const OLIVEYOUNG_API = {
+    BASE_URL: 'https://www.oliveyoung.co.kr',
+    STORE_FINDER_PATH: '/oystore/api/storeFinder/find-store',
+    PRODUCT_SEARCH_PATH: '/oystore/api/stock/product-search-v3',
+};

package/dist/services/oliveyoung/client.js

@@ -0,0 +1,90 @@
+/**
+ * 올리브영 Zyte 클라이언트
+ *
+ * Zyte extract API를 통해 올리브영 내부 API를 우회 호출합니다.
+ */
+import { OLIVEYOUNG_API } from './api.js';
+import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+async function zyteExtract(targetPath, requestBody, options = {}) {
+    const { timeout = 15000, apiKey } = options;
+    try {
+        const result = await requestByZyte({
+            apiKey,
+            timeout,
+            url: `${OLIVEYOUNG_API.BASE_URL}${targetPath}`,
+            method: 'POST',
+            headers: [
+                { name: 'Content-Type', value: 'application/json' },
+                { name: 'Accept', value: 'application/json' },
+                { name: 'X-Requested-With', value: 'XMLHttpRequest' },
+            ],
+            bodyText: JSON.stringify(requestBody),
+        });
+        if (result.statusCode !== 200 || !result.httpResponseBody) {
+            throw new Error(`올리브영 API 응답 실패: ${result.statusCode || 'unknown'}`);
+        }
+        const decodedBody = decodeBase64(result.httpResponseBody);
+        const parsedBody = JSON.parse(decodedBody);
+        if (parsedBody.status !== 'SUCCESS') {
+            throw new Error(`올리브영 API 상태 오류: ${parsedBody.status || 'UNKNOWN'}`);
+        }
+        return parsedBody;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('올리브영 API 요청 시간 초과');
+        }
+        throw error;
+    }
+}
+export async function fetchOliveyoungStores(params, options = {}) {
+    const payload = {
+        lat: params.latitude,
+        lon: params.longitude,
+        pageIdx: params.pageIdx,
+        searchWords: params.searchWords,
+        pogKeys: '',
+        serviceKeys: '',
+        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,
+    };
+}
+export async function fetchOliveyoungProducts(params, options = {}) {
+    const payload = {
+        includeSoldOut: params.includeSoldOut,
+        keyword: params.keyword,
+        page: params.page,
+        sort: params.sort,
+        size: params.size,
+    };
+    const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
+    const list = body.data?.serachList || body.data?.searchList || [];
+    const products = list.map((product) => ({
+        goodsNumber: product.goodsNumber || '',
+        goodsName: product.goodsName || '',
+        priceToPay: product.priceToPay || 0,
+        originalPrice: product.originalPrice || 0,
+        discountRate: product.discountRate || 0,
+        o2oStockFlag: Boolean(product.o2oStockFlag),
+        o2oRemainQuantity: product.o2oRemainQuantity || 0,
+    }));
+    return {
+        totalCount: body.data?.totalCount || 0,
+        nextPage: Boolean(body.data?.nextPage),
+        products,
+    };
+}

package/dist/services/oliveyoung/index.js

@@ -0,0 +1,28 @@
+/**
+ * 올리브영 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+const OLIVEYOUNG_METADATA = {
+    id: 'oliveyoung',
+    name: '올리브영',
+    version: '1.0.0',
+    description: '올리브영 주변 매장 탐색 및 재고 파악 서비스 (Zyte API 기반)',
+};
+class OliveyoungService {
+    options;
+    metadata = OLIVEYOUNG_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getTools() {
+        return [
+            createFindNearbyStoresTool(this.options.zyteApiKey),
+            createCheckInventoryTool(this.options.zyteApiKey),
+        ];
+    }
+}
+export function createOliveyoungService(options = {}) {
+    return new OliveyoungService(options);
+}
+export * from './types.js';

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

@@ -0,0 +1,87 @@
+/**
+ * 올리브영 재고 파악 도구
+ */
+import * as z from 'zod';
+import { fetchOliveyoungProducts, fetchOliveyoungStores } from '../client.js';
+async function checkInventory(args) {
+    const { keyword, latitude = 37.5665, longitude = 126.978, storeKeyword = '', page = 1, size = 20, sort = '01', includeSoldOut = false, storeLimit = 10, timeoutMs = 15000, zyteApiKey, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const [storeResult, productResult] = await Promise.all([
+        fetchOliveyoungStores({
+            latitude,
+            longitude,
+            pageIdx: 1,
+            searchWords: storeKeyword,
+        }, {
+            timeout: timeoutMs,
+            apiKey: zyteApiKey,
+        }),
+        fetchOliveyoungProducts({
+            keyword,
+            page,
+            size,
+            sort,
+            includeSoldOut,
+        }, {
+            timeout: timeoutMs,
+            apiKey: zyteApiKey,
+        }),
+    ]);
+    const inStockProducts = productResult.products.filter((product) => product.o2oStockFlag || product.o2oRemainQuantity > 0);
+    const result = {
+        keyword,
+        searchOptions: {
+            page,
+            size,
+            sort,
+            includeSoldOut,
+            storeKeyword,
+        },
+        location: {
+            latitude,
+            longitude,
+        },
+        nearbyStores: {
+            totalCount: storeResult.totalCount,
+            count: Math.min(storeLimit, storeResult.stores.length),
+            stores: storeResult.stores.slice(0, storeLimit),
+        },
+        inventory: {
+            totalCount: productResult.totalCount,
+            nextPage: productResult.nextPage,
+            inStockCount: inStockProducts.length,
+            outOfStockCount: productResult.products.length - inStockProducts.length,
+            products: productResult.products,
+        },
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createCheckInventoryTool(apiKey) {
+    return {
+        name: 'oliveyoung_check_inventory',
+        metadata: {
+            title: '올리브영 재고 파악',
+            description: '상품 키워드로 올리브영 재고(품절 포함 여부 선택 가능)를 조회하고, 주변 매장 정보와 함께 반환합니다.',
+            inputSchema: {
+                keyword: z.string().describe('재고를 확인할 상품 키워드 (예: 선크림, 립밤, 샴푸)'),
+                latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
+                longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
+                storeKeyword: z
+                    .string()
+                    .optional()
+                    .describe('주변 매장 필터 키워드 (예: 명동, 강남). 비우면 주변 매장 전체'),
+                page: z.number().optional().default(1).describe('상품 검색 페이지 번호 (기본값: 1)'),
+                size: z.number().optional().default(20).describe('페이지당 상품 수 (기본값: 20)'),
+                sort: z.string().optional().default('01').describe('정렬 코드 (기본값: 01)'),
+                includeSoldOut: z.boolean().optional().default(false).describe('품절 상품 포함 여부 (기본값: false)'),
+                storeLimit: z.number().optional().default(10).describe('반환할 주변 매장 최대 수 (기본값: 10)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => checkInventory({ ...args, zyteApiKey: apiKey })),
+    };
+}

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

@@ -0,0 +1,53 @@
+/**
+ * 올리브영 주변 매장 탐색 도구
+ */
+import * as z from 'zod';
+import { fetchOliveyoungStores } from '../client.js';
+async function findNearbyStores(args) {
+    const { latitude = 37.5665, longitude = 126.978, keyword = '', pageIdx = 1, limit = 20, timeoutMs = 15000, zyteApiKey, } = args;
+    const { totalCount, stores } = await fetchOliveyoungStores({
+        latitude,
+        longitude,
+        pageIdx,
+        searchWords: keyword,
+    }, {
+        timeout: timeoutMs,
+        apiKey: zyteApiKey,
+    });
+    const limitedStores = stores.slice(0, limit);
+    const result = {
+        location: {
+            latitude,
+            longitude,
+        },
+        keyword,
+        pageIdx,
+        totalCount,
+        count: limitedStores.length,
+        stores: limitedStores,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createFindNearbyStoresTool(apiKey) {
+    return {
+        name: 'oliveyoung_find_nearby_stores',
+        metadata: {
+            title: '올리브영 주변 매장 탐색',
+            description: '위치(위도/경도)와 키워드로 내 주변 올리브영 매장을 조회합니다.',
+            inputSchema: {
+                latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
+                longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
+                keyword: z
+                    .string()
+                    .optional()
+                    .describe('매장 검색어 (예: 강남, 명동, 신촌). 비우면 주변 매장 전체 조회'),
+                pageIdx: z.number().optional().default(1).describe('매장 결과 페이지 번호 (기본값: 1)'),
+                limit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: ((args) => findNearbyStores({ ...args, zyteApiKey: apiKey })),
+    };
+}

package/dist/services/oliveyoung/types.js

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

package/dist/tools/checkInventory.js

@@ -0,0 +1,98 @@
+/**
+ * 재고 확인 도구
+ *
+ * 다이소몰 API를 사용하여 매장별 재고를 확인합니다.
+ * API: https://mapi.daisomall.co.kr/ms/msg/newIntSelStr
+ */
+import { fetchJson } from '../utils/fetch.js';
+// 온라인 재고 조회
+async function fetchOnlineStock(productNo) {
+    const data = await fetchJson('https://mapi.daisomall.co.kr/ms/msg/selOnlStck', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ pdNo: productNo }),
+    });
+    if (!data.success) {
+        return 0;
+    }
+    return data.data?.stck || 0;
+}
+// 매장별 재고 조회
+async function fetchStoreInventory(productNo, lat, lng, page = 1, pageSize = 30, keyword = '') {
+    const data = await fetchJson('https://mapi.daisomall.co.kr/ms/msg/newIntSelStr', {
+        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 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 };
+}
+export async function checkInventory(args) {
+    const { productId, storeQuery = '', latitude = 37.5665, // 기본값: 서울 시청
+    longitude = 126.978, page = 1, pageSize = 30, } = args;
+    if (!productId || productId.trim().length === 0) {
+        throw new Error('상품 ID(productId)를 입력해주세요.');
+    }
+    // 온라인 재고와 매장 재고 동시 조회
+    const [onlineStock, storeResult] = await Promise.all([
+        fetchOnlineStock(productId),
+        fetchStoreInventory(productId, latitude, longitude, page, pageSize, storeQuery),
+    ]);
+    // 재고 있는 매장과 없는 매장 분류
+    const inStockStores = storeResult.stores.filter((s) => s.quantity > 0);
+    const outOfStockStores = storeResult.stores.filter((s) => s.quantity === 0);
+    const result = {
+        productId,
+        location: { latitude, longitude },
+        onlineStock,
+        storeInventory: {
+            totalStores: storeResult.totalCount,
+            inStockCount: inStockStores.length,
+            outOfStockCount: outOfStockStores.length,
+            page,
+            pageSize,
+            stores: storeResult.stores,
+        },
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/findStores.js

@@ -0,0 +1,125 @@
+/**
+ * 매장 찾기 도구
+ *
+ * 다이소 API를 사용하여 매장을 검색합니다.
+ * API: https://www.daiso.co.kr/cs/ajax/shop_search
+ */
+import { fetchHtml, fetchJson } from '../utils/fetch.js';
+// HTML에서 매장 정보 파싱
+function parseStoresFromHtml(html) {
+    const stores = [];
+    // bx-store div 태그의 시작 위치 찾기
+    const divStartRegex = /<div[^>]*class="bx-store"[^>]*>/gi;
+    let divMatch;
+    while ((divMatch = divStartRegex.exec(html)) !== null) {
+        const startIdx = divMatch.index;
+        const divTag = divMatch[0];
+        // 해당 div의 끝 찾기 (다음 bx-store div나 특정 마커까지)
+        const endIdx = html.indexOf('<div class="bx-store"', startIdx + 1);
+        const blockEnd = endIdx > 0 ? endIdx : startIdx + 2000;
+        const block = html.slice(startIdx, blockEnd);
+        // data 속성 추출
+        const startMatch = /data-start="(\d+)"/.exec(divTag);
+        const endMatch = /data-end="(\d+)"/.exec(divTag);
+        const latMatch = /data-lat="([^"]+)"/.exec(divTag);
+        const lngMatch = /data-lng="([^"]+)"/.exec(divTag);
+        const infoMatch = /data-info='([^']*)'/.exec(divTag);
+        if (!startMatch || !endMatch || !latMatch || !lngMatch)
+            continue;
+        // 매장명, 전화번호, 주소 추출
+        const nameMatch = /<h4[^>]*class="place"[^>]*>([^<]+)<\/h4>/i.exec(block);
+        const phoneMatch = /<em[^>]*class="phone"[^>]*>([^<]*)<\/em>/i.exec(block);
+        const addrMatch = /<p[^>]*class="addr"[^>]*>([^<]+)<\/p>/i.exec(block);
+        if (!nameMatch)
+            continue;
+        // data-info JSON 파싱
+        let info = {};
+        if (infoMatch) {
+            try {
+                const infoStr = infoMatch[1].replace(/&quot;/g, '"').replace(/&amp;/g, '&');
+                info = JSON.parse(infoStr);
+            }
+            catch {
+                // JSON 파싱 실패 시 빈 객체 사용
+            }
+        }
+        const options = {
+            parking: info.shp_pak === 'Y',
+            ramp: info.entrramp === 'Y',
+            elevator: info.elvtor === 'Y',
+            cashless: info.ptcard === 'Y',
+            photoSticker: info.ptstk === 'Y',
+            nameSticker: info.nmstk === 'Y',
+            simCard: info.usim_yn === 'Y',
+            taxFree: info.tax_free === 'Y',
+            groupOrder: info['ext.group_yn'] === 'Y' || info.group_yn === 'Y',
+            pickup: info.online_yn === 'Y',
+        };
+        // 영업 시간 포맷팅
+        const formatTime = (time) => {
+            if (time.length === 4) {
+                return `${time.slice(0, 2)}:${time.slice(2)}`;
+            }
+            return time;
+        };
+        stores.push({
+            name: nameMatch[1].trim(),
+            phone: phoneMatch ? phoneMatch[1].replace('T.', '').trim() : '',
+            address: addrMatch ? addrMatch[1].trim() : '',
+            lat: parseFloat(latMatch[1]),
+            lng: parseFloat(lngMatch[1]),
+            openTime: formatTime(startMatch[1]),
+            closeTime: formatTime(endMatch[1]),
+            options,
+        });
+    }
+    return stores;
+}
+// 다이소 매장 검색 API 호출
+async function fetchStores(keyword, sido, gugun, dong) {
+    const url = new URL('https://www.daiso.co.kr/cs/ajax/shop_search');
+    url.searchParams.set('name_address', keyword || '');
+    url.searchParams.set('sido', sido || '');
+    url.searchParams.set('gugun', gugun || '');
+    url.searchParams.set('dong', dong || '');
+    const html = await fetchHtml(url.toString());
+    return parseStoresFromHtml(html);
+}
+// 시/도별 구/군 목록 조회
+export async function getDistricts(sido) {
+    const url = new URL('https://www.daiso.co.kr/cs/ajax/sido_search');
+    url.searchParams.set('sido', sido);
+    const data = await fetchJson(url.toString());
+    return data.map((item) => item.value);
+}
+// 구/군별 동 목록 조회
+export async function getNeighborhoods(sido, gugun) {
+    const url = new URL('https://www.daiso.co.kr/cs/ajax/gugun_search');
+    url.searchParams.set('sido', sido);
+    url.searchParams.set('gugun', gugun);
+    const data = await fetchJson(url.toString());
+    return data.map((item) => item.value);
+}
+export async function findStores(args) {
+    const { keyword, sido, gugun, dong, limit = 50 } = args;
+    // 최소한 하나의 검색 조건이 필요
+    if (!keyword && !sido) {
+        throw new Error('검색어(keyword) 또는 지역(sido)을 입력해주세요.');
+    }
+    const stores = await fetchStores(keyword, sido, gugun, dong);
+    const limitedStores = stores.slice(0, limit);
+    const result = {
+        searchParams: { keyword, sido, gugun, dong },
+        totalCount: stores.length,
+        count: limitedStores.length,
+        stores: limitedStores,
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/getPriceInfo.js

@@ -0,0 +1,77 @@
+/**
+ * 가격 정보 조회 도구
+ *
+ * 다이소몰 API를 사용하여 상품의 가격 정보를 조회합니다.
+ * 상품 검색 API를 통해 가격 정보를 가져옵니다.
+ */
+import { fetchJson } from '../utils/fetch.js';
+// 이미지 URL 생성
+function getImageUrl(path) {
+    if (!path)
+        return undefined;
+    return `https://img.daisomall.co.kr${path}`;
+}
+// 상품 ID로 검색
+async function fetchProductById(productId) {
+    const url = new URL('https://prdm.daisomall.co.kr/ssn/search/FindStoreGoods');
+    url.searchParams.set('searchTerm', productId);
+    url.searchParams.set('cntPerPage', '10');
+    url.searchParams.set('pageNum', '1');
+    const data = await fetchJson(url.toString());
+    if (!data.resultSet?.result?.[0]?.resultDocuments) {
+        return null;
+    }
+    const docs = data.resultSet.result[0].resultDocuments;
+    // 정확한 ID 매칭 시도
+    const exactMatch = docs.find((doc) => doc.PD_NO === productId);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    return docs.length > 0 ? docs[0] : null;
+}
+// 상품명으로 검색
+async function fetchProductByName(productName) {
+    const url = new URL('https://prdm.daisomall.co.kr/ssn/search/FindStoreGoods');
+    url.searchParams.set('searchTerm', productName);
+    url.searchParams.set('cntPerPage', '1');
+    url.searchParams.set('pageNum', '1');
+    const data = await fetchJson(url.toString());
+    if (!data.resultSet?.result?.[0]?.resultDocuments?.length) {
+        return null;
+    }
+    return data.resultSet.result[0].resultDocuments[0];
+}
+export async function getPriceInfo(args) {
+    const { productId, productName } = args;
+    if (!productId && !productName) {
+        throw new Error('상품 ID(productId) 또는 상품명(productName)을 입력해주세요.');
+    }
+    let product = null;
+    if (productId) {
+        product = await fetchProductById(productId);
+    }
+    else if (productName) {
+        product = await fetchProductByName(productName);
+    }
+    if (!product) {
+        throw new Error(`상품을 찾을 수 없습니다: ${productId || productName}`);
+    }
+    const price = parseInt(product.PD_PRC) || 0;
+    const result = {
+        productId: product.PD_NO,
+        productName: product.PDNM || product.EXH_PD_NM,
+        currentPrice: price,
+        currency: 'KRW',
+        imageUrl: getImageUrl(product.ATCH_FILE_URL),
+        brand: product.BRND_NM || undefined,
+        soldOut: product.SOLD_OUT_YN === 'Y',
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+}

package/dist/tools/searchProducts.js

@@ -0,0 +1,61 @@
+/**
+ * 제품 검색 도구
+ *
+ * 다이소몰 API를 사용하여 제품을 검색합니다.
+ * API: https://prdm.daisomall.co.kr/ssn/search/FindStoreGoods
+ */
+import { fetchJson } from '../utils/fetch.js';
+// 이미지 URL 생성
+function getImageUrl(path) {
+    if (!path)
+        return undefined;
+    return `https://img.daisomall.co.kr${path}`;
+}
+// 다이소몰 API에서 상품 검색
+async function fetchProducts(query, page = 1, pageSize = 30) {
+    const url = new URL('https://prdm.daisomall.co.kr/ssn/search/FindStoreGoods');
+    url.searchParams.set('searchTerm', query);
+    url.searchParams.set('cntPerPage', pageSize.toString());
+    url.searchParams.set('pageNum', page.toString());
+    const data = await fetchJson(url.toString());
+    // 결과가 없는 경우
+    if (!data.resultSet?.result?.[0]?.resultDocuments) {
+        return { products: [], totalCount: 0 };
+    }
+    const result = data.resultSet.result[0];
+    const totalCount = result.totalSize || 0;
+    const products = result.resultDocuments.map((doc) => ({
+        id: doc.PD_NO,
+        name: doc.PDNM || doc.EXH_PD_NM || '',
+        price: parseInt(doc.PD_PRC) || 0,
+        imageUrl: getImageUrl(doc.ATCH_FILE_URL),
+        brand: doc.BRND_NM || undefined,
+        soldOut: doc.SOLD_OUT_YN === 'Y',
+        isNew: doc.NEW_PD_YN === 'Y',
+        pickupAvailable: doc.PKUP_OR_PSBL_YN === 'Y',
+    }));
+    return { products, totalCount };
+}
+export async function searchProducts(args) {
+    const { query, page = 1, pageSize = 30 } = args;
+    if (!query || query.trim().length === 0) {
+        throw new Error('검색어를 입력해주세요.');
+    }
+    const { products, totalCount } = await fetchProducts(query, page, pageSize);
+    const result = {
+        query,
+        page,
+        pageSize,
+        totalCount,
+        count: products.length,
+        products,
+    };
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+}

package/dist/types/index.js

@@ -0,0 +1,4 @@
+/**
+ * 다이소 MCP 서버 타입 정의
+ */
+export {};