daiso 1.1.0 → 1.2.1

package/README.md

@@ -94,6 +94,8 @@
 
 </div>
 
+> Zyte 유료 호출을 중지했습니다. 무료 원본 조회를 우선하며 일부 서비스는 별도 실행 환경이 필요합니다. [비용 정책과 서비스별 상태](docs/zyte-free-access.md)를 확인하세요.
+
 > [!IMPORTANT]
 > 최근 공개 서버 사용량이 크게 증가하여 2026년 7월 18일부터 올리브영·CGV·CU·GS25·롯데마트의 검색을 포함한 공개 GET API에 IP당 하루 합산 3,000회(KST 기준)의 호출 제한을 적용합니다. 한도를 초과하는 사용이 필요하다면 Daiso MCP는 오픈 소스이므로 이 저장소를 직접 배포해 이용해 주세요.
 

package/dist/api/configStatus.js

@@ -9,7 +9,8 @@ export function buildConfigStatus(bindings) {
         },
         zyteApiKey: {
             configured: isConfigured(bindings?.ZYTE_API_KEY),
-            usedBy: ['oliveyoung', 'gs25', 'cu', 'seveneleven', 'lottemart', 'cgv'],
+            enabled: false,
+            usedBy: [],
         },
         naverLocalSearch: {
             configured: isConfigured(bindings?.NAVER_CLIENT_ID) && isConfigured(bindings?.NAVER_CLIENT_SECRET),

package/dist/api/handlers.js

@@ -44,7 +44,10 @@ export async function handleOliveyoungSearchProducts(c) {
             sort,
             includeSoldOut,
         }, {
-            apiKey: c.env?.ZYTE_API_KEY,
+            relayUrl: c.env?.OY_RELAY_URL,
+            relayToken: c.env?.OY_RELAY_TOKEN,
+            accessClientId: c.env?.OY_ACCESS_CLIENT_ID,
+            accessClientSecret: c.env?.OY_ACCESS_CLIENT_SECRET,
             timeout: timeoutMs,
         });
         return successResponse(c, {
@@ -79,7 +82,10 @@ export async function handleOliveyoungFindStores(c) {
             pageIdx,
             searchWords: keyword,
         }, {
-            apiKey: c.env?.ZYTE_API_KEY,
+            relayUrl: c.env?.OY_RELAY_URL,
+            relayToken: c.env?.OY_RELAY_TOKEN,
+            accessClientId: c.env?.OY_ACCESS_CLIENT_ID,
+            accessClientSecret: c.env?.OY_ACCESS_CLIENT_SECRET,
             timeout: timeoutMs,
         });
         return successResponse(c, {
@@ -120,7 +126,10 @@ export async function handleOliveyoungCheckInventory(c) {
                 pageIdx: 1,
                 searchWords: storeKeyword,
             }, {
-                apiKey: c.env.ZYTE_API_KEY,
+                relayUrl: c.env?.OY_RELAY_URL,
+                relayToken: c.env?.OY_RELAY_TOKEN,
+                accessClientId: c.env?.OY_ACCESS_CLIENT_ID,
+                accessClientSecret: c.env?.OY_ACCESS_CLIENT_SECRET,
                 timeout: timeoutMs,
             }),
             fetchOliveyoungProducts({
@@ -130,7 +139,10 @@ export async function handleOliveyoungCheckInventory(c) {
                 sort,
                 includeSoldOut,
             }, {
-                apiKey: c.env.ZYTE_API_KEY,
+                relayUrl: c.env?.OY_RELAY_URL,
+                relayToken: c.env?.OY_RELAY_TOKEN,
+                accessClientId: c.env?.OY_ACCESS_CLIENT_ID,
+                accessClientSecret: c.env?.OY_ACCESS_CLIENT_SECRET,
                 timeout: timeoutMs,
             }),
         ]);
@@ -140,7 +152,10 @@ export async function handleOliveyoungCheckInventory(c) {
             storeKeyword,
             maxProducts: Math.min(productResult.products.length, stockCheckLimit),
         }, {
-            apiKey: c.env.ZYTE_API_KEY,
+            relayUrl: c.env?.OY_RELAY_URL,
+            relayToken: c.env?.OY_RELAY_TOKEN,
+            accessClientId: c.env?.OY_ACCESS_CLIENT_ID,
+            accessClientSecret: c.env?.OY_ACCESS_CLIENT_SECRET,
             timeout: timeoutMs,
         });
         const inStockCount = enrichedInventory.products.filter((product) => product.inStock).length;

package/dist/core/errors.js

@@ -1,6 +1,7 @@
 /**
  * MCP/API 공통 에러 진단 구조
  */
+export const ZYTE_COST_POLICY_MESSAGE = 'Zyte 유료 호출은 비용 정책에 따라 비활성화되어 있습니다.';
 const SERVICE_PREFIXES = [
     'daiso',
     'gs25',
@@ -50,15 +51,23 @@ function buildHint(retryable) {
 }
 export function toStandardErrorDiagnostics(code, message, options = {}) {
     const inferred = inferServiceAndOperation(code);
+    const costPolicyError = message.includes(ZYTE_COST_POLICY_MESSAGE);
     // 실제 Zyte 진단 문구만 설정 오류로 취급해 일반적인 접근 차단과 구분합니다.
     const configurationError = [
         'Zyte API 호출 실패: 403 Your account has been suspended.',
         'Zyte API 호출 실패: 403 account suspended',
         'ZYTE_API_KEY가 설정되지 않았습니다.',
     ].some((diagnostic) => message.includes(diagnostic));
-    const gs25AuthenticationError = code === 'GS25_UPSTREAM_UNAVAILABLE' &&
-        message.includes('GS25 재고 서비스 인증을 사용할 수 없습니다.');
-    const retryable = !configurationError &&
+    const gs25AuthenticationError = message.includes('GS25 재고 서비스 인증을 사용할 수 없습니다.');
+    const oliveyoungRelayConfigurationError = [
+        '올리브영 릴레이 URL은 HTTPS 또는 로컬 HTTP 주소여야 합니다.',
+        'OY_RELAY_TOKEN이 필요합니다.',
+        '올리브영 Access 서비스 토큰 설정이 필요합니다.',
+        '올리브영 직접 요청 실패. 운영자는 OY_RELAY_URL과 OY_RELAY_TOKEN으로 브라우저 릴레이를 설정해주세요.',
+    ].includes(message);
+    const retryable = !oliveyoungRelayConfigurationError &&
+        !costPolicyError &&
+        !configurationError &&
         !gs25AuthenticationError &&
         isRetryable(code, options.status || options.upstreamStatus);
     return {
@@ -69,11 +78,15 @@ export function toStandardErrorDiagnostics(code, message, options = {}) {
         service: options.service || inferred.service,
         operation: options.operation || inferred.operation,
         upstreamStatus: options.upstreamStatus,
-        hint: gs25AuthenticationError
-            ? '운영자는 GS25_API_KEY 설정을 확인하세요.'
-            : configurationError
-                ? '운영자는 ZYTE_API_KEY 설정과 Zyte 계정 상태를 확인하세요.'
-                : buildHint(retryable),
+        hint: oliveyoungRelayConfigurationError
+            ? '운영자는 OY_RELAY_URL과 OY_RELAY_TOKEN 및 브라우저 릴레이 실행 상태를 확인하세요.'
+            : costPolicyError
+                ? ZYTE_COST_POLICY_MESSAGE
+                : gs25AuthenticationError
+                    ? '운영자는 GS25_API_KEY 설정을 확인하세요.'
+                    : configurationError
+                        ? '운영자는 ZYTE_API_KEY 설정과 Zyte 계정 상태를 확인하세요.'
+                        : buildHint(retryable),
     };
 }
 export function getErrorMessage(error) {

package/dist/index.js

@@ -85,7 +85,10 @@ const createRegistry = (bindings) => {
             googleMapsApiKey: bindings?.GOOGLE_MAPS_API_KEY,
         }),
         () => createOliveyoungService({
-            zyteApiKey: bindings?.ZYTE_API_KEY,
+            relayUrl: bindings?.OY_RELAY_URL,
+            relayToken: bindings?.OY_RELAY_TOKEN,
+            accessClientId: bindings?.OY_ACCESS_CLIENT_ID,
+            accessClientSecret: bindings?.OY_ACCESS_CLIENT_SECRET,
         }),
     ]);
     return registry;

package/dist/services/cgv/errors.js

@@ -1,9 +1,10 @@
 /**
  * CGV 원본 및 대체 전송 경로를 사용할 수 없는 상태
  */
+import { ZYTE_COST_POLICY_MESSAGE } from '../../core/errors.js';
 export class CgvUpstreamUnavailableError extends Error {
     constructor() {
-        super('CGV 원본 서비스에 연결할 수 없습니다. 잠시 후 다시 시도해주세요.');
+        super(`CGV 원본 서비스에 연결할 수 없습니다. ${ZYTE_COST_POLICY_MESSAGE}`);
         this.name = 'CgvUpstreamUnavailableError';
     }
 }

package/dist/services/cgv/transport.js

@@ -1,10 +1,9 @@
 /**
  * CGV 전송 계층
  *
- * 서명 헤더 생성, 직접 호출, Zyte fallback을 담당합니다.
+ * 서명 헤더를 생성하고 직접 호출합니다. 유료 대체 경로는 사용하지 않습니다.
  */
 import { createTimeoutController } from '../../utils/http.js';
-import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
 import { CGV_API } from './api.js';
 import { CgvUpstreamUnavailableError } from './errors.js';
 function toBase64(bytes) {
@@ -36,28 +35,7 @@ async function parseJsonResponse(response) {
         throw new Error(text.slice(0, 120) || 'CGV API 응답 파싱 실패');
     }
 }
-async function requestByZyteCgv(path, searchParams, timeout, apiKey) {
-    const url = `${CGV_API.BASE_URL}${path}?${searchParams.toString()}`;
-    const timestamp = Math.floor(Date.now() / 1000).toString();
-    const signature = await createSignature(path, '', timestamp);
-    const result = await requestByZyte({
-        apiKey,
-        timeout,
-        url,
-        headers: [
-            { name: 'Accept', value: 'application/json' },
-            { name: 'Accept-Language', value: 'ko-KR' },
-            { name: 'X-TIMESTAMP', value: timestamp },
-            { name: 'X-SIGNATURE', value: signature },
-        ],
-        tags: { service: 'cgv' },
-    });
-    if (result.statusCode === 401 || result.statusCode === 403) {
-        throw new CgvUpstreamUnavailableError();
-    }
-    return decodeZyteHttpBody(result);
-}
-export async function requestCgv(path, searchParams, timeout = 15000, zyteApiKey) {
+export async function requestCgv(path, searchParams, timeout = 15000, _zyteApiKey) {
     const url = `${CGV_API.BASE_URL}${path}?${searchParams.toString()}`;
     const timestamp = Math.floor(Date.now() / 1000).toString();
     const signature = await createSignature(path, '', timestamp);
@@ -77,19 +55,7 @@ export async function requestCgv(path, searchParams, timeout = 15000, zyteApiKey
             return await parseJsonResponse(response);
         }
         if (response.status === 401 || response.status === 403) {
-            const normalizedZyteApiKey = zyteApiKey?.trim();
-            if (!normalizedZyteApiKey) {
-                throw new CgvUpstreamUnavailableError();
-            }
-            try {
-                return await requestByZyteCgv(path, searchParams, timeout, normalizedZyteApiKey);
-            }
-            catch (fallbackError) {
-                if (fallbackError instanceof CgvUpstreamUnavailableError) {
-                    throw fallbackError;
-                }
-                throw new CgvUpstreamUnavailableError();
-            }
+            throw new CgvUpstreamUnavailableError();
         }
         throw new Error(`CGV API 호출 실패: ${response.status}`);
     }

package/dist/services/cu/client.js

@@ -2,7 +2,7 @@
  * CU API 클라이언트
  */
 import { fetchJson } from '../../utils/http.js';
-import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { ZYTE_COST_POLICY_MESSAGE } from '../../core/errors.js';
 import { fetchJsonWithZyteFallback } from '../../utils/zyteJsonFallback.js';
 import { CU_API } from './api.js';
 import { cuStockUnavailableReason } from './upstreamError.js';
@@ -57,7 +57,7 @@ async function requestCuJson(path, body, options = {}) {
         zyteTags: { service: 'cu' },
     });
 }
-async function requestCuWebHtml(path, body, apiKey, timeout = 15000) {
+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}`;
@@ -71,23 +71,7 @@ async function requestCuWebHtml(path, body, apiKey, timeout = 15000) {
         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,
-                tags: { service: 'cu' },
-            });
-            if (result.statusCode === 200 && result.httpResponseBody) {
-                return decodeBase64(result.httpResponseBody);
-            }
-        }
-        catch {
-            // 직접 호출 실패 시 Zyte 재시도도 실패하면 원본 에러를 반환합니다.
-        }
+        throw new Error(ZYTE_COST_POLICY_MESSAGE);
     }
     throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
 }

package/dist/services/cu/upstreamError.js

@@ -7,9 +7,5 @@ export function cuStockUnavailableReason(error) {
     if (error instanceof HttpError && [400, 403, 429].includes(error.status)) {
         return `CU 재고 API가 차단되었습니다 (${error.status} Request Blocked).`;
     }
-    const message = error instanceof Error ? error.message : '';
-    if (message.includes('Zyte API 호출 실패: 520') || message.includes('Zyte 대상 응답 실패: 520')) {
-        return 'CU 재고 API가 차단되었습니다 (Zyte Website Ban 520).';
-    }
     return null;
 }

package/dist/services/gs25/productSearch.js

@@ -3,7 +3,7 @@
  */
 /* c8 ignore start */
 import { fetchJson, HttpError } from '../../utils/http.js';
-import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
+import { requestByZyte } from '../../utils/zyte.js';
 import { GS25_API } from './api.js';
 import { toNumber } from './storeUtils.js';
 const GS25_TOTAL_SEARCH_HEADERS = {
@@ -37,20 +37,7 @@ async function fetchGs25TotalSearchResponse(query, options) {
         if (!(error instanceof HttpError) || error.status !== 403 || !zyteApiKey) {
             throw error;
         }
-        const result = await requestByZyte({
-            apiKey: zyteApiKey,
-            url: endpoint.toString(),
-            method: 'POST',
-            timeout,
-            retries: 1,
-            headers: Object.entries(GS25_TOTAL_SEARCH_HEADERS).map(([name, value]) => ({
-                name,
-                value,
-            })),
-            bodyText,
-            tags: { service: 'gs25' },
-        });
-        return decodeZyteHttpBody(result);
+        return requestByZyte({ apiKey: zyteApiKey, url: endpoint.toString() });
     }
 }
 export async function fetchGs25NormalizedKeyword(keyword, options = {}) {

package/dist/services/gs25/storeStockTransport.js

@@ -2,7 +2,6 @@
  * GS25 재고 원본 요청과 Zyte 대체 경로
  */
 import { fetchJson, HttpError } from '../../utils/http.js';
-import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
 import { Gs25UpstreamUnavailableError } from './errors.js';
 function withApiKey(headers, apiKey) {
     const normalizedApiKey = apiKey?.trim();
@@ -26,30 +25,6 @@ export async function fetchGs25StoreStockResponse(url, options, headers) {
         if (!(error instanceof HttpError) || !isAuthenticationStatus(error.status)) {
             throw error;
         }
-        const zyteApiKey = options.zyteApiKey?.trim();
-        if (error.status === 401 || !zyteApiKey) {
-            throw new Gs25UpstreamUnavailableError();
-        }
-        try {
-            const result = await requestByZyte({
-                apiKey: zyteApiKey,
-                url,
-                method: 'GET',
-                timeout: options.timeout,
-                retries: 1,
-                headers: Object.entries(requestHeaders).map(([name, value]) => ({ name, value })),
-                tags: { service: 'gs25' },
-            });
-            if (isAuthenticationStatus(result.statusCode)) {
-                throw new Gs25UpstreamUnavailableError();
-            }
-            return decodeZyteHttpBody(result);
-        }
-        catch (fallbackError) {
-            if (fallbackError instanceof Gs25UpstreamUnavailableError) {
-                throw fallbackError;
-            }
-            throw new Gs25UpstreamUnavailableError();
-        }
+        throw new Gs25UpstreamUnavailableError();
     }
 }

package/dist/services/lottemart/session.js

@@ -2,9 +2,9 @@
  * 롯데마트 세션 쿠키 관리
  */
 import { HttpError, fetchWithTimeout } from '../../utils/http.js';
-import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { ZYTE_COST_POLICY_MESSAGE } from '../../core/errors.js';
 import { LOTTEMART_API } from './api.js';
-import { fetchLotteMartSocketResponse, toLotteMartBodyText, withLotteMartSessionCookie, } from './socketTransport.js';
+import { fetchLotteMartSocketResponse, withLotteMartSessionCookie, } from './socketTransport.js';
 export { __testOnlyCreateLotteMartSocketResponse, __testOnlyFetchLotteMartSocketResponse, withLotteMartSessionCookie, } from './socketTransport.js';
 const SESSION_CACHE_TTL_MS = 5 * 60 * 1000;
 const FALLBACK_TIMEOUT_MS = 5000;
@@ -67,28 +67,6 @@ async function fetchLotteMartResponse(url, init, timeout, sessionCookie) {
         throw directError;
     }
 }
-function toZyteHeaders(headers) {
-    return Array.from(headers.entries()).map(([name, value]) => ({ name, value }));
-}
-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: toLotteMartBodyText(init.body),
-        tags: { service: 'lottemart' },
-    });
-    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;
@@ -122,29 +100,15 @@ export async function probeLotteMartRequest(url, init, timeout, sessionCookie, z
         });
     }
     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,
-            });
-        }
+        attempts.push({
+            used: 'zyte',
+            success: false,
+            status: null,
+            statusText: null,
+            error: ZYTE_COST_POLICY_MESSAGE,
+            bodyPreview: null,
+            sessionCookie: sessionCookie || null,
+        });
     }
     return attempts;
 }
@@ -186,8 +150,7 @@ export async function fetchLotteMartHtml(url, init, timeout, sessionCookie, zyte
     }
     catch (error) {
         if (zyteApiKey && error instanceof Error && !error.message.includes('Zyte')) {
-            const fallbackCookie = await getCachedLotteMartSessionCookie(timeout);
-            return fetchLotteMartHtmlByZyte(url, init, Math.min(timeout, FALLBACK_TIMEOUT_MS), fallbackCookie || sessionCookie, zyteApiKey);
+            throw new Error(ZYTE_COST_POLICY_MESSAGE);
         }
         throw error;
     }

package/dist/services/oliveyoung/client.js

@@ -1,11 +1,11 @@
 /**
- * 올리브영 Zyte 클라이언트
+ * 올리브영 무료 API 클라이언트
  *
- * Zyte extract API를 통해 올리브영 내부 API를 우회 호출합니다.
+ * 공식 API 또는 운영자가 설정한 브라우저 릴레이를 호출합니다.
  */
 import { OLIVEYOUNG_API } from './api.js';
 import { resolveOliveyoungImageUrl, resolveOliveyoungInStock, resolveOliveyoungStoreStock, } from './normalize.js';
-import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { requestOliveyoung } from './transport.js';
 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();
@@ -56,39 +56,6 @@ function writeStaleResult(cache, cacheKey, result, cloneResult) {
         result: cloneResult(result),
     });
 }
-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),
-            tags: { service: 'oliveyoung' },
-        });
-        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,
@@ -102,7 +69,7 @@ export async function fetchOliveyoungStores(params, options = {}) {
     };
     const cacheKey = createOliveyoungStoreSearchCacheKey(params);
     try {
-        const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
+        const body = await requestOliveyoung(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
         const stores = (body.data?.storeList || []).map((store) => ({
             storeCode: store.storeCode || '',
             storeName: store.storeName || '',
@@ -137,7 +104,7 @@ export async function fetchOliveyoungProducts(params, options = {}) {
     };
     const cacheKey = createOliveyoungProductSearchCacheKey(params);
     try {
-        const body = await zyteExtract(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
+        const body = await requestOliveyoung(OLIVEYOUNG_API.PRODUCT_SEARCH_PATH, payload, options);
         const list = body.data?.serachList || body.data?.searchList || [];
         const products = list.map((product) => {
             const o2oStockFlag = Boolean(product.o2oStockFlag);
@@ -185,7 +152,7 @@ async function fetchOliveyoungProductId(goodsNumber, options = {}) {
     if (cached && cached.expiresAt > now) {
         return cached.productId;
     }
-    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_GOODS_INFO_PATH, { goodsNo: normalizedGoodsNumber }, options);
+    const body = await requestOliveyoung(OLIVEYOUNG_API.STOCK_GOODS_INFO_PATH, { goodsNo: normalizedGoodsNumber }, options);
     const productId = body.data?.goodsInfo?.masterGoodsNumber || '';
     if (productId) {
         oliveyoungProductIdCache.set(normalizedGoodsNumber, {
@@ -198,7 +165,7 @@ async function fetchOliveyoungProductId(goodsNumber, options = {}) {
 async function fetchOliveyoungStockStores(params, options = {}) {
     const cacheKey = createOliveyoungStockStoresCacheKey(params);
     try {
-        const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
+        const body = await requestOliveyoung(OLIVEYOUNG_API.STOCK_STORES_PATH, {
             productId: params.productId,
             lat: params.latitude,
             lon: params.longitude,

package/dist/services/oliveyoung/index.js

@@ -8,7 +8,7 @@ const OLIVEYOUNG_METADATA = {
     id: 'oliveyoung',
     name: '올리브영',
     version: '1.0.0',
-    description: '올리브영 상품 검색, 주변 매장 탐색 및 재고 파악 서비스 (Zyte API 기반)',
+    description: '올리브영 상품 검색, 주변 매장 탐색 및 재고 파악 서비스 (무료 직접 요청 및 브라우저 릴레이)',
 };
 class OliveyoungService {
     options;
@@ -18,9 +18,9 @@ class OliveyoungService {
     }
     getTools() {
         return [
-            createSearchProductsTool(this.options.zyteApiKey),
-            createFindNearbyStoresTool(this.options.zyteApiKey),
-            createCheckInventoryTool(this.options.zyteApiKey),
+            createSearchProductsTool(this.options.zyteApiKey, this.options),
+            createFindNearbyStoresTool(this.options.zyteApiKey, this.options),
+            createCheckInventoryTool(this.options.zyteApiKey, this.options),
         ];
     }
 }

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

@@ -3,7 +3,7 @@
  */
 import * as z from 'zod';
 import { enrichOliveyoungProductsWithNearbyStoreInventory, fetchOliveyoungProducts, fetchOliveyoungStores, } from '../client.js';
-async function checkInventory(args) {
+async function checkInventory(args, transport) {
     const { keyword, latitude = 37.5665, longitude = 126.978, storeKeyword = '', page = 1, size = 20, sort = '01', includeSoldOut = false, storeLimit = 10, stockCheckLimit = 5, timeoutMs = 15000, zyteApiKey, } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
@@ -17,6 +17,7 @@ async function checkInventory(args) {
         }, {
             timeout: timeoutMs,
             apiKey: zyteApiKey,
+            ...transport,
         }),
         fetchOliveyoungProducts({
             keyword,
@@ -27,6 +28,7 @@ async function checkInventory(args) {
         }, {
             timeout: timeoutMs,
             apiKey: zyteApiKey,
+            ...transport,
         }),
     ]);
     const enrichedInventory = await enrichOliveyoungProductsWithNearbyStoreInventory(productResult.products, {
@@ -37,6 +39,7 @@ async function checkInventory(args) {
     }, {
         timeout: timeoutMs,
         apiKey: zyteApiKey,
+        ...transport,
     });
     const inStockProducts = enrichedInventory.products.filter((product) => product.inStock);
     const result = {
@@ -71,7 +74,7 @@ async function checkInventory(args) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createCheckInventoryTool(apiKey) {
+export function createCheckInventoryTool(apiKey, transport = {}) {
     return {
         name: 'oliveyoung_check_inventory',
         metadata: {
@@ -98,6 +101,6 @@ export function createCheckInventoryTool(apiKey) {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => checkInventory({ ...args, zyteApiKey: apiKey })),
+        handler: ((args) => checkInventory({ ...args, zyteApiKey: apiKey }, transport)),
     };
 }

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

@@ -3,7 +3,7 @@
  */
 import * as z from 'zod';
 import { fetchOliveyoungStores } from '../client.js';
-async function findNearbyStores(args) {
+async function findNearbyStores(args, transport) {
     const { latitude = 37.5665, longitude = 126.978, keyword = '', pageIdx = 1, limit = 20, timeoutMs = 15000, zyteApiKey, } = args;
     const { totalCount, stores } = await fetchOliveyoungStores({
         latitude,
@@ -13,6 +13,7 @@ async function findNearbyStores(args) {
     }, {
         timeout: timeoutMs,
         apiKey: zyteApiKey,
+        ...transport,
     });
     const limitedStores = stores.slice(0, limit);
     const result = {
@@ -30,7 +31,7 @@ async function findNearbyStores(args) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createFindNearbyStoresTool(apiKey) {
+export function createFindNearbyStoresTool(apiKey, transport = {}) {
     return {
         name: 'oliveyoung_find_nearby_stores',
         metadata: {
@@ -48,6 +49,6 @@ export function createFindNearbyStoresTool(apiKey) {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => findNearbyStores({ ...args, zyteApiKey: apiKey })),
+        handler: ((args) => findNearbyStores({ ...args, zyteApiKey: apiKey }, transport)),
     };
 }

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

@@ -3,7 +3,7 @@
  */
 import * as z from 'zod';
 import { fetchOliveyoungProducts } from '../client.js';
-async function searchProducts(args) {
+async function searchProducts(args, transport) {
     const { keyword, page = 1, size = 20, sort = '01', includeSoldOut = false, timeoutMs = 15000, zyteApiKey, } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
@@ -17,6 +17,7 @@ async function searchProducts(args) {
     }, {
         timeout: timeoutMs,
         apiKey: zyteApiKey,
+        ...transport,
     });
     return {
         content: [
@@ -37,7 +38,7 @@ async function searchProducts(args) {
         ],
     };
 }
-export function createSearchProductsTool(apiKey) {
+export function createSearchProductsTool(apiKey, transport = {}) {
     return {
         name: 'oliveyoung_search_products',
         metadata: {
@@ -52,6 +53,6 @@ export function createSearchProductsTool(apiKey) {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => searchProducts({ ...args, zyteApiKey: apiKey })),
+        handler: ((args) => searchProducts({ ...args, zyteApiKey: apiKey }, transport)),
     };
 }

package/dist/services/oliveyoung/transport.js

@@ -0,0 +1,65 @@
+/** 올리브영 무료 직접 요청 및 운영자가 설정한 브라우저 릴레이 전송. */
+import { fetchJson } from '../../utils/http.js';
+import { OLIVEYOUNG_API } from './api.js';
+export async function requestOliveyoung(path, body, options = {}) {
+    const { timeout = 15000, relayUrl, relayToken } = options;
+    const headers = {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        'X-Requested-With': 'XMLHttpRequest',
+    };
+    let url = `${OLIVEYOUNG_API.BASE_URL}${path}`;
+    if (relayUrl) {
+        let relay;
+        try {
+            relay = new URL(relayUrl);
+        }
+        catch {
+            throw new Error('올리브영 릴레이 URL은 HTTPS 또는 로컬 HTTP 주소여야 합니다.');
+        }
+        if (relay.username ||
+            relay.password ||
+            relay.search ||
+            relay.hash ||
+            (relay.protocol !== 'https:' &&
+                !(relay.protocol === 'http:' && ['127.0.0.1', 'localhost'].includes(relay.hostname)))) {
+            throw new Error('올리브영 릴레이 URL은 HTTPS 또는 로컬 HTTP 주소여야 합니다.');
+        }
+        if (!relayToken?.trim())
+            throw new Error('OY_RELAY_TOKEN이 필요합니다.');
+        url = `${relayUrl.replace(/\/$/, '')}/v1/oliveyoung/${path.split('/').pop()}`;
+        headers.Authorization = `Bearer ${relayToken}`;
+        const { accessClientId, accessClientSecret } = options;
+        if (accessClientId !== undefined || accessClientSecret !== undefined) {
+            if (!accessClientId?.trim() || !accessClientSecret?.trim()) {
+                throw new Error('올리브영 Access 서비스 토큰 설정이 필요합니다.');
+            }
+            headers['CF-Access-Client-Id'] = accessClientId;
+            headers['CF-Access-Client-Secret'] = accessClientSecret;
+        }
+    }
+    let result;
+    try {
+        result = await fetchJson(url, {
+            method: 'POST',
+            redirect: 'error',
+            headers,
+            body: JSON.stringify(body),
+            timeout,
+            retries: 0,
+            expectedStatus: 200,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('올리브영 API 요청 시간 초과');
+        }
+        if (relayUrl)
+            throw new Error('올리브영 브라우저 릴레이 요청 실패');
+        throw new Error('올리브영 직접 요청 실패. 운영자는 OY_RELAY_URL과 OY_RELAY_TOKEN으로 브라우저 릴레이를 설정해주세요.', { cause: error });
+    }
+    if (result?.status !== 'SUCCESS') {
+        throw new Error(`올리브영 API 상태 오류: ${result?.status || 'UNKNOWN'}`);
+    }
+    return result;
+}

package/dist/services/seveneleven/client.js

@@ -2,6 +2,7 @@
  * 세븐일레븐 API 클라이언트
  */
 /* c8 ignore start */
+import { withSevenElevenReadCache } from './readCache.js';
 import { fetchJsonWithZyteFallback } from '../../utils/zyteJsonFallback.js';
 import { SEVENELEVEN_API } from './api.js';
 const SEVENELEVEN_DEFAULT_HEADERS = {
@@ -111,7 +112,7 @@ function normalizeStores(items) {
 async function requestSevenElevenJson(path, method, body, options = {}) {
     const { timeout = 15000, zyteApiKey } = options;
     const url = `${SEVENELEVEN_API.BASE_URL}${path}`;
-    return fetchJsonWithZyteFallback(url, {
+    return withSevenElevenReadCache(path, body, timeout, () => fetchJsonWithZyteFallback(url, {
         ...SEVENELEVEN_DEFAULT_FETCH_OPTIONS,
         method,
         retryUnsafeMethods: method === 'POST',
@@ -120,7 +121,7 @@ async function requestSevenElevenJson(path, method, body, options = {}) {
         body: method === 'POST' ? JSON.stringify(body || {}) : undefined,
         zyteApiKey,
         zyteTags: { service: 'seveneleven' },
-    });
+    }));
 }
 export async function searchSevenElevenProducts(params, options = {}) {
     const { query, page = 1, size = 20 } = params;

package/dist/services/seveneleven/readCache.js

@@ -0,0 +1,49 @@
+/** 공개 상품·매장 조회를 REST와 MCP에서 함께 재사용합니다. 재고는 저장하지 않습니다. */
+import { SEVENELEVEN_API } from './api.js';
+const MAX_ENTRIES = 128;
+const TTL_BY_PATH = new Map([
+    [SEVENELEVEN_API.SEARCH_GOODS_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.SEARCH_STORE_PATH, 30 * 60_000],
+    [SEVENELEVEN_API.SEARCH_POPWORD_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.PRODUCT_PAGES_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.PRODUCT_ISSUES_PATH, 5 * 60_000],
+    [SEVENELEVEN_API.EXHIBITION_MAIN_PATH, 5 * 60_000],
+]);
+const values = new Map();
+const pending = new Map();
+export function clearSevenElevenReadCache() {
+    values.clear();
+    pending.clear();
+}
+export async function withSevenElevenReadCache(path, body, timeout, request) {
+    const ttl = TTL_BY_PATH.get(path.split('?')[0]);
+    if (!ttl)
+        return request();
+    const key = JSON.stringify([path, body, timeout]);
+    const cached = values.get(key);
+    if (cached && cached.expiresAt > Date.now()) {
+        return structuredClone(cached.value);
+    }
+    values.delete(key);
+    const existing = pending.get(key);
+    if (existing)
+        return structuredClone(await existing);
+    // 부하가 높아져도 진행 중인 조회 키를 무제한으로 보관하지 않습니다.
+    if (pending.size >= MAX_ENTRIES)
+        return request();
+    const promise = request().then((value) => {
+        if (value.success === true && value.data !== undefined) {
+            if (values.size >= MAX_ENTRIES)
+                values.delete(values.keys().next().value);
+            values.set(key, { expiresAt: Date.now() + ttl, value: structuredClone(value) });
+        }
+        return value;
+    });
+    pending.set(key, promise);
+    try {
+        return structuredClone(await promise);
+    }
+    finally {
+        pending.delete(key);
+    }
+}

package/dist/utils/http.js

@@ -66,7 +66,7 @@ function parseRetryAfterDelayMs(response) {
     return null;
 }
 async function requestWithTimeout(url, options, readResponse) {
-    const { timeout = 10000, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, ...restOptions } = options;
+    const { timeout = 10000, retries = 0, retryDelayMs = 250, retryStatusCodes = DEFAULT_RETRY_STATUS_CODES, retryUnsafeMethods = false, retryMethods = DEFAULT_RETRY_METHODS, onRetry, expectedStatus: _expectedStatus, ...restOptions } = options;
     const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
     const method = normalizeMethod(restOptions.method);
     const retryAllowed = canRetryMethod(method, retryMethods, retryUnsafeMethods);
@@ -132,7 +132,7 @@ async function readTextResponse(url, options) {
 }
 export async function fetchJson(url, options = {}) {
     const { response, body } = await readTextResponse(url, options);
-    if (!response.ok) {
+    if (!response.ok || (options.expectedStatus !== undefined && response.status !== options.expectedStatus)) {
         throw new HttpError(response.status, response.statusText, body);
     }
     if (/^\s*(?:<!doctype\s+html\b|<html\b)/i.test(body)) {

package/dist/utils/zyte.js

@@ -1,29 +1,7 @@
 /**
  * Zyte Extract API 공통 유틸리티
  */
-import { createTimeoutController } from './http.js';
-export function resolveZyteApiKey(apiKey) {
-    if (apiKey && apiKey.trim().length > 0) {
-        return apiKey;
-    }
-    /* c8 ignore start */
-    if (typeof process !== 'undefined' && process.env?.ZYTE_API_KEY) {
-        return process.env.ZYTE_API_KEY;
-    }
-    /* c8 ignore end */
-    throw new Error('ZYTE_API_KEY가 설정되지 않았습니다. .env 또는 Cloudflare Worker Secret을 확인해주세요.');
-}
-export function encodeBasicAuth(apiKey) {
-    if (typeof btoa === 'function') {
-        return btoa(`${apiKey}:`);
-    }
-    /* c8 ignore start */
-    if (typeof Buffer !== 'undefined') {
-        return Buffer.from(`${apiKey}:`).toString('base64');
-    }
-    /* c8 ignore end */
-    throw new Error('Basic 인증 인코딩을 지원하지 않는 런타임입니다.');
-}
+import { ZYTE_COST_POLICY_MESSAGE } from '../core/errors.js';
 export function decodeBase64(value) {
     if (typeof atob === 'function') {
         const binary = atob(value);
@@ -37,95 +15,9 @@ export function decodeBase64(value) {
     /* c8 ignore end */
     throw new Error('Base64 디코딩을 지원하지 않는 런타임입니다.');
 }
-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 parseZyteResponseBody(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return {
-            detail: text.trim().replace(/\s+/g, ' ').slice(0, 300),
-        };
-    }
-}
-function wait(ms) {
-    if (ms <= 0) {
-        return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-export async function requestByZyte(options) {
-    const { timeout = 15000, retries = 1, retryDelayMs = 250, url, method = 'GET', headers = [], bodyText, apiKey, tags, } = options;
-    const auth = encodeBasicAuth(resolveZyteApiKey(apiKey));
-    const maxAttempts = Math.max(1, Math.trunc(retries) + 1);
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const { controller, timeoutId } = createTimeoutController(timeout);
-        try {
-            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,
-                        ...(tags ? { tags } : {}),
-                    }),
-                    signal: controller.signal,
-                });
-            }
-            catch (error) {
-                if (error instanceof TypeError) {
-                    throw new RetryableZyteError(error.message);
-                }
-                throw error;
-            }
-            const result = parseZyteResponseBody(await response.text());
-            if (!response.ok) {
-                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 (!isRetryableError(error) || attempt >= maxAttempts) {
-                throw error;
-            }
-            await wait(retryDelayMs);
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    throw new Error('Zyte API 호출 실패');
+/** 키와 재시도 설정에 관계없이 유료 네트워크 경로를 차단합니다. */
+export async function requestByZyte(_options) {
+    throw new Error(ZYTE_COST_POLICY_MESSAGE);
 }
 export function decodeZyteHttpBody(result) {
     if (!result.httpResponseBody) {

package/dist/utils/zyteJsonFallback.js

@@ -1,37 +1,9 @@
 /**
- * 차단 응답에만 Zyte를 사용하는 JSON 전송 유틸리티
+ * 직접 JSON 조회와 유료 대체 경로 중지 안내
  */
 import { fetchJson, HttpError } from './http.js';
-import { decodeZyteHttpBody, requestByZyte, } from './zyte.js';
+import { requestByZyte } from './zyte.js';
 const ZYTE_FALLBACK_STATUSES = new Set([400, 403, 429]);
-const ZYTE_METHODS = new Set([
-    'GET',
-    'POST',
-    'PUT',
-    'PATCH',
-    'DELETE',
-]);
-function normalizeMethod(method) {
-    const normalized = (method || 'GET').toUpperCase();
-    if (!ZYTE_METHODS.has(normalized)) {
-        throw new Error(`Zyte에서 지원하지 않는 HTTP 메서드입니다: ${normalized}`);
-    }
-    return normalized;
-}
-function toZyteHeaders(headers) {
-    const normalized = new Headers(headers);
-    const result = [];
-    normalized.forEach((value, name) => {
-        result.push({ name, value });
-    });
-    return result;
-}
-function assertSuccessfulTarget(result) {
-    const status = result.statusCode;
-    if (typeof status !== 'number' || status < 200 || status >= 300) {
-        throw new Error(`Zyte 대상 응답 실패: ${status ?? '알 수 없음'}`);
-    }
-}
 function hasZyteApiKey(apiKey) {
     if (apiKey?.trim()) {
         return true;
@@ -52,16 +24,5 @@ export async function fetchJsonWithZyteFallback(url, options = {}) {
             throw error;
         }
     }
-    const result = await requestByZyte({
-        apiKey: zyteApiKey,
-        url,
-        timeout: directOptions.timeout,
-        retries: 0,
-        method: normalizeMethod(directOptions.method),
-        headers: toZyteHeaders(directOptions.headers),
-        bodyText: typeof directOptions.body === 'string' ? directOptions.body : undefined,
-        tags: zyteTags,
-    });
-    assertSuccessfulTarget(result);
-    return decodeZyteHttpBody(result);
+    return requestByZyte({ apiKey: zyteApiKey, url, tags: zyteTags });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "daiso",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "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": {