daiso 1.0.4 → 1.0.5

package/dist/services/lottemart/session.js

@@ -0,0 +1,331 @@
+/**
+ * 롯데마트 세션 쿠키 관리
+ */
+import { HttpError, fetchWithTimeout } from '../../utils/http.js';
+import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { LOTTEMART_API } from './api.js';
+const SESSION_CACHE_TTL_MS = 5 * 60 * 1000;
+let sessionCache = null;
+function extractSessionCookie(response) {
+    const cookieHeaders = response.headers;
+    const cookieCandidates = cookieHeaders.getSetCookie
+        ? cookieHeaders.getSetCookie()
+        : [response.headers.get('set-cookie') || ''];
+    const matched = cookieCandidates
+        .flatMap((value) => value.split(','))
+        .map((value) => value.trim())
+        .find((value) => value.startsWith('ASPSESSIONID'));
+    return matched ? matched.split(';')[0].trim() : '';
+}
+function withSocketTimeout(operation, timeout) {
+    const timeoutMs = Math.max(1, Math.trunc(timeout));
+    return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => resolve(null), timeoutMs);
+        operation.then((value) => {
+            clearTimeout(timeoutId);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timeoutId);
+            reject(error);
+        });
+    });
+}
+export function __testOnlyCreateLotteMartSocketResponse(raw) {
+    const delimiter = new TextEncoder().encode('\r\n\r\n');
+    let boundary = -1;
+    for (let index = 0; index <= raw.length - delimiter.length; index += 1) {
+        let matched = true;
+        for (let inner = 0; inner < delimiter.length; inner += 1) {
+            if (raw[index + inner] !== delimiter[inner]) {
+                matched = false;
+                break;
+            }
+        }
+        if (matched) {
+            boundary = index;
+            break;
+        }
+    }
+    if (boundary < 0) {
+        return null;
+    }
+    const headerText = new TextDecoder().decode(raw.slice(0, boundary));
+    if (!headerText.startsWith('HTTP/')) {
+        return null;
+    }
+    const bodyBytes = raw.slice(boundary + delimiter.length);
+    const headerLinesRaw = headerText.split('\r\n');
+    const statusLine = headerLinesRaw.shift();
+    const [, statusCodeText = '500', ...statusTextParts] = statusLine.split(' ');
+    const responseHeaders = new Headers();
+    for (const line of headerLinesRaw) {
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex < 0) {
+            continue;
+        }
+        responseHeaders.append(line.slice(0, separatorIndex).trim(), line.slice(separatorIndex + 1).trim());
+    }
+    return new Response(bodyBytes, {
+        status: parseInt(statusCodeText, 10) || 500,
+        statusText: statusTextParts.join(' ').trim(),
+        headers: responseHeaders,
+    });
+}
+export async function __testOnlyFetchLotteMartSocketResponse(url, init, sessionCookie, connectFn, timeout) {
+    const requestUrl = new URL(url);
+    const headers = withLotteMartSessionCookie({
+        Accept: 'text/html, */*; q=0.01',
+        Host: LOTTEMART_API.ORIGIN_HOST,
+        Origin: 'https://company.lottemart.com',
+        Referer: LOTTEMART_API.ORIGIN_REFERER,
+        Connection: 'close',
+        ...init.headers,
+    }, sessionCookie);
+    const bodyText = toBodyText(init.body) || '';
+    if (bodyText.length > 0 && !headers.has('Content-Length')) {
+        headers.set('Content-Length', String(new TextEncoder().encode(bodyText).length));
+    }
+    const headerLines = Array.from(headers.entries()).map(([name, value]) => `${name}: ${value}`);
+    const path = `${requestUrl.pathname}${requestUrl.search}`;
+    const requestText = [`${init.method || 'GET'} ${path} HTTP/1.1`, ...headerLines, '', bodyText].join('\r\n');
+    const socket = connectFn({
+        hostname: LOTTEMART_API.SOCKET_HOST,
+        port: 80,
+    }, { allowHalfOpen: true });
+    const writer = socket.writable.getWriter();
+    const encodedRequest = new TextEncoder().encode(requestText);
+    if ((await withSocketTimeout(writer.write(encodedRequest), timeout)) === null) {
+        void writer.abort().catch(Boolean);
+        return null;
+    }
+    if ((await withSocketTimeout(writer.close(), timeout)) === null) {
+        void writer.abort().catch(Boolean);
+        return null;
+    }
+    const reader = socket.readable.getReader();
+    const chunks = [];
+    try {
+        while (true) {
+            const readResult = await withSocketTimeout(reader.read(), timeout);
+            if (readResult === null) {
+                await reader.cancel().catch(() => undefined);
+                return null;
+            }
+            const { value, done } = readResult;
+            if (done) {
+                break;
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const raw = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        raw.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return __testOnlyCreateLotteMartSocketResponse(raw);
+}
+/* c8 ignore start */
+async function fetchLotteMartSocketResponse(url, init, sessionCookie, timeout) {
+    let connectFn = null;
+    try {
+        const socketsModule = await import('cloudflare:sockets');
+        connectFn = socketsModule.connect;
+    }
+    catch {
+        return null;
+    }
+    if (!connectFn) {
+        return null;
+    }
+    return __testOnlyFetchLotteMartSocketResponse(url, init, sessionCookie, connectFn, timeout);
+}
+/* c8 ignore end */
+function cacheSessionCookie(cookie) {
+    const normalized = cookie.trim();
+    if (normalized.length === 0) {
+        return '';
+    }
+    sessionCache = {
+        expiresAt: Date.now() + SESSION_CACHE_TTL_MS,
+        cookie: normalized,
+    };
+    return normalized;
+}
+function cacheSessionCookieFromResponse(response) {
+    const cookie = extractSessionCookie(response);
+    return cacheSessionCookie(cookie);
+}
+export async function getCachedLotteMartSessionCookie(_timeout, forceRefresh = false) {
+    if (forceRefresh) {
+        sessionCache = null;
+    }
+    if (sessionCache && sessionCache.expiresAt > Date.now()) {
+        return sessionCache.cookie;
+    }
+    return '';
+}
+export async function getFreshLotteMartSessionCookie(timeout) {
+    return getCachedLotteMartSessionCookie(timeout, true);
+}
+export function withLotteMartSessionCookie(headers, sessionCookie) {
+    const result = new Headers(headers);
+    if (sessionCookie.trim().length > 0) {
+        result.set('Cookie', sessionCookie);
+    }
+    return result;
+}
+async function fetchLotteMartResponse(url, init, timeout, sessionCookie) {
+    const socketResponse = await fetchLotteMartSocketResponse(url, init, sessionCookie, timeout);
+    if (socketResponse) {
+        return socketResponse;
+    }
+    return fetchWithTimeout(url, {
+        ...init,
+        timeout,
+        headers: withLotteMartSessionCookie({
+            Accept: 'text/html, */*; q=0.01',
+            ...init.headers,
+        }, sessionCookie),
+    });
+}
+function toZyteHeaders(headers) {
+    return Array.from(headers.entries()).map(([name, value]) => ({ name, value }));
+}
+function toBodyText(body) {
+    if (typeof body === 'string') {
+        return body;
+    }
+    if (body instanceof URLSearchParams) {
+        return body.toString();
+    }
+    return undefined;
+}
+async function fetchLotteMartHtmlByZyte(url, init, timeout, sessionCookie, zyteApiKey) {
+    const headers = withLotteMartSessionCookie({
+        Accept: 'text/html, */*; q=0.01',
+        ...init.headers,
+    }, sessionCookie);
+    const result = await requestByZyte({
+        apiKey: zyteApiKey,
+        url,
+        timeout,
+        method: init.method || 'GET',
+        headers: toZyteHeaders(headers),
+        bodyText: toBodyText(init.body),
+    });
+    if (!result.httpResponseBody) {
+        throw new Error('Zyte HTTP 응답 본문이 비어 있습니다.');
+    }
+    return decodeBase64(result.httpResponseBody);
+}
+function toBodyPreview(bodyText) {
+    const normalized = bodyText.trim().replace(/\s+/g, ' ');
+    return normalized.length > 0 ? normalized.slice(0, 300) : null;
+}
+export async function probeLotteMartRequest(url, init, timeout, sessionCookie, zyteApiKey) {
+    const attempts = [];
+    try {
+        const response = await fetchLotteMartResponse(url, init, timeout, sessionCookie);
+        const bodyText = await response.text();
+        attempts.push({
+            used: 'direct',
+            success: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            error: response.ok ? null : new HttpError(response.status, response.statusText, bodyText).message,
+            bodyPreview: toBodyPreview(bodyText),
+            sessionCookie: extractSessionCookie(response) || null,
+        });
+    }
+    catch (error) {
+        attempts.push({
+            used: 'direct',
+            success: false,
+            status: null,
+            statusText: null,
+            error: error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.',
+            bodyPreview: null,
+            sessionCookie: null,
+        });
+    }
+    if (zyteApiKey) {
+        try {
+            const bodyText = await fetchLotteMartHtmlByZyte(url, init, timeout, sessionCookie, zyteApiKey);
+            attempts.push({
+                used: 'zyte',
+                success: true,
+                status: 200,
+                statusText: 'OK',
+                error: null,
+                bodyPreview: toBodyPreview(bodyText),
+                sessionCookie: sessionCookie || null,
+            });
+        }
+        catch (error) {
+            attempts.push({
+                used: 'zyte',
+                success: false,
+                status: null,
+                statusText: null,
+                error: error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.',
+                bodyPreview: null,
+                sessionCookie: sessionCookie || null,
+            });
+        }
+    }
+    return attempts;
+}
+export async function fetchLotteMartHtml(url, init, timeout, sessionCookie, zyteApiKey) {
+    try {
+        const response = await fetchLotteMartResponse(url, init, timeout, sessionCookie);
+        const cachedCookie = cacheSessionCookieFromResponse(response);
+        let bodyText;
+        try {
+            bodyText = await response.text();
+        }
+        catch (error) {
+            if (sessionCookie.trim().length === 0 && cachedCookie.length > 0) {
+                const retried = await fetchLotteMartResponse(url, init, timeout, cachedCookie);
+                cacheSessionCookieFromResponse(retried);
+                const retriedBodyText = await retried.text();
+                if (!retried.ok) {
+                    throw new HttpError(retried.status, retried.statusText, retriedBodyText);
+                }
+                return retriedBodyText;
+            }
+            throw error;
+        }
+        if (!response.ok) {
+            throw new HttpError(response.status, response.statusText, bodyText);
+        }
+        if (bodyText.trim().length === 0 && sessionCookie.trim().length === 0 && cachedCookie.length > 0) {
+            const retried = await fetchLotteMartResponse(url, init, timeout, cachedCookie);
+            cacheSessionCookieFromResponse(retried);
+            const retriedBodyText = await retried.text();
+            if (!retried.ok) {
+                throw new HttpError(retried.status, retried.statusText, retriedBodyText);
+            }
+            return retriedBodyText;
+        }
+        return bodyText;
+    }
+    catch (error) {
+        if (zyteApiKey && error instanceof Error && !error.message.includes('Zyte')) {
+            const fallbackCookie = await getCachedLotteMartSessionCookie(timeout);
+            return fetchLotteMartHtmlByZyte(url, init, timeout, fallbackCookie || sessionCookie, zyteApiKey);
+        }
+        throw error;
+    }
+}
+export async function fetchLotteMartPageWithSession(path, init, timeout, sessionCookie, zyteApiKey) {
+    return fetchLotteMartHtml(new URL(path, LOTTEMART_API.BASE_URL).toString(), init, timeout, sessionCookie, zyteApiKey);
+}
+export function __testOnlyClearLotteMartSessionCache() {
+    sessionCache = null;
+}

package/dist/services/lottemart/storeSearch.js

@@ -0,0 +1,52 @@
+/**
+ * 롯데마트 매장 검색 보조 로직
+ */
+import { LOTTEMART_AREAS } from './api.js';
+import { calculateDistanceM, matchesBrandVariant, matchesKeyword } from './parser.js';
+export function normalizeArea(area) {
+    const trimmed = (area || '').trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    if (trimmed === '제주') {
+        return '기타';
+    }
+    return LOTTEMART_AREAS.find((value) => value === trimmed);
+}
+export function toDisplayArea(area) {
+    return area === '기타' ? '제주' : area;
+}
+export function getTargetAreas(area) {
+    return area ? [area] : [...LOTTEMART_AREAS];
+}
+export function attachDistance(stores, latitude, longitude) {
+    return stores.map((store) => {
+        if (typeof latitude !== 'number' || typeof longitude !== 'number') {
+            return store;
+        }
+        if (store.latitude === 0 || store.longitude === 0) {
+            return store;
+        }
+        return {
+            ...store,
+            distanceM: calculateDistanceM(latitude, longitude, store.latitude, store.longitude),
+        };
+    });
+}
+export async function fetchAllStoresForAreaList(areas, fetcher) {
+    return (await Promise.all(areas.map((value) => fetcher(value)))).flat();
+}
+export async function fetchKeywordMatchedStores(areas, keyword, brandVariant, limit, fetcher) {
+    const stores = [];
+    for (const currentArea of areas) {
+        const areaStores = await fetcher(currentArea);
+        const matched = areaStores
+            .filter((store) => matchesKeyword(store, keyword))
+            .filter((store) => matchesBrandVariant(store, brandVariant));
+        stores.push(...matched);
+        if (stores.length >= limit) {
+            break;
+        }
+    }
+    return stores;
+}

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

@@ -0,0 +1,67 @@
+/**
+ * 롯데마트 주변 매장 탐색 도구
+ */
+import * as z from 'zod';
+import { fetchLotteMartStores } from '../client.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from '../config.js';
+async function findNearbyStores(args) {
+    const { area, keyword = '', brandVariant = '', latitude, longitude, limit = 20, timeoutMs = DEFAULT_LOTTEMART_TIMEOUT_MS, googleMapsApiKey, zyteApiKey, } = args;
+    const result = await fetchLotteMartStores({
+        area,
+        keyword,
+        brandVariant,
+        latitude,
+        longitude,
+        limit,
+    }, {
+        timeout: timeoutMs,
+        googleMapsApiKey,
+        zyteApiKey,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    area: area || null,
+                    keyword,
+                    brandVariant: brandVariant || null,
+                    geocodeUsed: result.geocodeUsed,
+                    location: result.location,
+                    count: result.stores.length,
+                    stores: result.stores,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createFindNearbyStoresTool(googleMapsApiKey, zyteApiKey) {
+    return {
+        name: 'lottemart_find_nearby_stores',
+        metadata: {
+            title: '롯데마트 주변 매장 탐색',
+            description: '지역/키워드와 좌표 기준으로 롯데마트 계열 매장을 조회하고 거리순으로 정렬합니다.',
+            inputSchema: {
+                area: z.string().optional().describe('지역 (예: 서울, 경기, 제주)'),
+                keyword: z.string().optional().describe('매장명/주소 키워드 (예: 강변, 잠실, 서울역)'),
+                brandVariant: z
+                    .enum(['lottemart', 'toysrus', 'max', 'bottlebunker', 'mealguru', 'grandgrocery', 'other'])
+                    .optional()
+                    .describe('브랜드 변형 필터'),
+                latitude: z.number().optional().describe('위도 (미입력 시 keyword 지오코딩 시도)'),
+                longitude: z.number().optional().describe('경도 (미입력 시 keyword 지오코딩 시도)'),
+                limit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
+                timeoutMs: z
+                    .number()
+                    .optional()
+                    .default(DEFAULT_LOTTEMART_TIMEOUT_MS)
+                    .describe(`요청 제한 시간(ms, 기본값: ${DEFAULT_LOTTEMART_TIMEOUT_MS})`),
+            },
+        },
+        handler: ((args) => findNearbyStores({
+            ...args,
+            googleMapsApiKey: args.googleMapsApiKey || googleMapsApiKey,
+            zyteApiKey: args.zyteApiKey || zyteApiKey,
+        })),
+    };
+}

package/dist/services/lottemart/tools/searchProducts.js

@@ -0,0 +1,62 @@
+/**
+ * 롯데마트 상품 검색 도구
+ */
+import * as z from 'zod';
+import { searchLotteMartProducts } from '../client.js';
+import { DEFAULT_LOTTEMART_TIMEOUT_MS } from '../config.js';
+async function searchProducts(args) {
+    const { area, storeCode, storeName, keyword, pageLimit = 3, timeoutMs = DEFAULT_LOTTEMART_TIMEOUT_MS, zyteApiKey, } = args;
+    const result = await searchLotteMartProducts({
+        area,
+        storeCode,
+        storeName,
+        keyword,
+        pageLimit,
+    }, {
+        timeout: timeoutMs,
+        zyteApiKey,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    area: result.area,
+                    storeCode: result.storeCode,
+                    storeName: result.storeName,
+                    keyword,
+                    pageLimit,
+                    totalCount: result.totalCount,
+                    totalPages: result.totalPages,
+                    count: result.products.length,
+                    products: result.products,
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createSearchProductsTool(zyteApiKey) {
+    return {
+        name: 'lottemart_search_products',
+        metadata: {
+            title: '롯데마트 상품 검색',
+            description: '특정 롯데마트 매장을 기준으로 상품 가격과 재고를 조회합니다.',
+            inputSchema: {
+                area: z.string().optional().describe('지역 (storeCode 미입력 시 storeName 해석에 사용)'),
+                storeCode: z.string().optional().describe('매장 코드 (예: 2301)'),
+                storeName: z.string().optional().describe('매장명 (예: 강변점)'),
+                keyword: z.string().describe('상품 검색어 (예: 콜라, 우유, 과자)'),
+                pageLimit: z.number().optional().default(3).describe('추가 조회할 최대 페이지 수 (기본값: 3)'),
+                timeoutMs: z
+                    .number()
+                    .optional()
+                    .default(DEFAULT_LOTTEMART_TIMEOUT_MS)
+                    .describe(`요청 제한 시간(ms, 기본값: ${DEFAULT_LOTTEMART_TIMEOUT_MS})`),
+            },
+        },
+        handler: ((args) => searchProducts({
+            ...args,
+            zyteApiKey: args.zyteApiKey || zyteApiKey,
+        })),
+    };
+}

package/dist/services/lottemart/types.js

@@ -0,0 +1,4 @@
+/**
+ * 롯데마트 타입 정의
+ */
+export {};

package/dist/services/lottemart/zetta.js

@@ -0,0 +1,105 @@
+/**
+ * 롯데마트 제타 상품 검색 fallback
+ */
+import { fetchJson } from '../../utils/http.js';
+import { dedupeProducts } from './parser.js';
+import { normalizeArea } from './storeSearch.js';
+const ZETTA_PRODUCT_SEARCH_URL = 'https://lottemartzetta.com/api/webproductpagews/v6/product-pages/search';
+function toZettaProductPrice(product) {
+    const parsed = Number.parseFloat(product.price?.amount || '');
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+function toZettaProductBarcode(retailerProductId) {
+    return (retailerProductId || '').replace(/^OS/i, '').trim();
+}
+function mapZettaProduct(area, storeCode, storeName, keyword, product) {
+    const productName = (product.name || '').trim();
+    if (productName.length === 0) {
+        return null;
+    }
+    return {
+        area,
+        storeCode,
+        storeName,
+        keyword,
+        productName,
+        barcode: toZettaProductBarcode(product.retailerProductId),
+        spec: (product.packSizeDescription || '').trim(),
+        manufacturer: (product.brand || '').trim(),
+        price: toZettaProductPrice(product),
+        stockQuantity: product.available === false ? 0 : 1,
+    };
+}
+function createZettaProductSearchUrl(keyword, pageToken) {
+    const endpoint = new URL(ZETTA_PRODUCT_SEARCH_URL);
+    endpoint.searchParams.set('q', keyword);
+    endpoint.searchParams.set('tag', 'web');
+    endpoint.searchParams.set('includeAdditionalPageInfo', pageToken ? 'false' : 'true');
+    endpoint.searchParams.set('maxProductsToDecorate', '50');
+    endpoint.searchParams.set('maxPageSize', '50');
+    if (pageToken) {
+        endpoint.searchParams.set('pageToken', pageToken);
+    }
+    return endpoint.toString();
+}
+export function createZettaFallbackStore(params) {
+    const storeCode = (params.storeCode || '').trim();
+    const storeName = (params.storeName || '').trim();
+    return {
+        area: normalizeArea(params.area || '') || '서울',
+        storeCode: storeCode || 'zetta',
+        storeName: storeName || `롯데마트 ${storeCode}`,
+        brandVariant: 'lottemart',
+    };
+}
+export async function fetchZettaLotteMartProductsWithPrimaryError(resolvedStore, keyword, pageLimit, timeout, error) {
+    try {
+        return await fetchZettaLotteMartProducts(resolvedStore, keyword, pageLimit, timeout);
+    }
+    catch (fallbackError) {
+        const primaryMessage = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : '알 수 없는 오류가 발생했습니다.';
+        throw new Error(`롯데마트 상품 조회 실패: 기존 경로(${primaryMessage}), 제타 경로(${fallbackMessage})`);
+    }
+}
+function clampZettaPageLimit(pageLimit) {
+    if (pageLimit < 1) {
+        return 1;
+    }
+    if (pageLimit > 5) {
+        return 5;
+    }
+    return pageLimit;
+}
+async function fetchZettaLotteMartProducts(resolvedStore, keyword, pageLimit, timeout) {
+    const products = [];
+    let nextPageToken;
+    let fetchedPages = 0;
+    const maxPage = clampZettaPageLimit(pageLimit);
+    do {
+        const response = await fetchJson(createZettaProductSearchUrl(keyword, nextPageToken), {
+            timeout,
+            headers: {
+                Accept: 'application/json,text/plain,*/*',
+                'Accept-Language': 'ko-KR,ko;q=0.9',
+                Referer: `https://lottemartzetta.com/products/search?q=${encodeURIComponent(keyword)}`,
+                'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125 Safari/537.36',
+            },
+        });
+        fetchedPages += 1;
+        products.push(...(response.productGroups || [])
+            .flatMap((group) => group.decoratedProducts || [])
+            .map((product) => mapZettaProduct(resolvedStore.area, resolvedStore.storeCode, resolvedStore.storeName, keyword, product))
+            .filter((product) => product !== null));
+        nextPageToken = response.metadata?.nextPageToken;
+    } while (nextPageToken && fetchedPages < maxPage);
+    const dedupedProducts = dedupeProducts(products);
+    return {
+        area: resolvedStore.area,
+        storeCode: resolvedStore.storeCode,
+        storeName: resolvedStore.storeName,
+        totalCount: dedupedProducts.length,
+        totalPages: nextPageToken ? fetchedPages + 1 : fetchedPages,
+        products: dedupedProducts,
+    };
+}