daiso 1.0.5 → 1.0.6

package/dist/cliInteractive.js

@@ -10,6 +10,42 @@ import { fetchEnvelope, fetchStoresWithKeywordFallback } from './cli/interactive
 import { askMenu, askNextAction, askNonEmpty, askYesNo, printStoreDetail } from './cli/interactivePrompt.js';
 import { parseLotteCinemaTheaters, printTheaterDetail, runCuItemSearch, runDaisoItemSearch, runLotteCinemaSearch, runOliveyoungItemSearch, } from './cli/interactiveItemSearch.js';
 import { buildDaisoStoreKeywordVariants, isRecord, parseDaisoProducts, parseStores, toText } from './utils/cliInteractiveHelpers.js';
+function isLocationToken(token) {
+    return /(?:역|점|동|구|시|군|읍|면|로|길)$/.test(token);
+}
+export function inferDaisoFreeTextIntent(input) {
+    const tokens = input.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length <= 1) {
+        const value = tokens[0] || input.trim();
+        return { productQuery: value, storeKeyword: value };
+    }
+    const locationIndex = tokens.findIndex(isLocationToken);
+    if (locationIndex >= 0) {
+        const storeKeyword = tokens[locationIndex];
+        const productQuery = tokens.filter((_, index) => index !== locationIndex).join(' ').trim() || input.trim();
+        return { productQuery, storeKeyword };
+    }
+    const storeKeyword = tokens[tokens.length - 1];
+    const productQuery = tokens.slice(0, -1).join(' ').trim() || input.trim();
+    return { productQuery, storeKeyword };
+}
+async function askServiceChoice(prompt, writeOut) {
+    while (true) {
+        const answer = await prompt.ask('서비스 번호를 선택하세요 (0: 종료): ');
+        const picked = Number.parseInt(answer, 10);
+        if (!Number.isNaN(picked) && String(picked) === answer.trim()) {
+            if (picked >= 0 && picked <= 4) {
+                return picked;
+            }
+            writeOut('번호로 입력하세요. 0부터 4 사이에서 선택할 수 있습니다.');
+            continue;
+        }
+        if (answer.trim().length > 0) {
+            return answer.trim();
+        }
+        writeOut('번호로 입력하세요. 0부터 4 사이에서 선택할 수 있습니다.');
+    }
+}
 function createPrompt() {
     const rl = createInterface({ input, output });
     return {
@@ -38,6 +74,7 @@ export const cliInteractiveTestables = {
     askNonEmpty,
     askNextAction,
     printStoreDetail,
+    inferDaisoFreeTextIntent,
     runDaisoItemSearch,
     runOliveyoungItemSearch,
     runCuItemSearch,
@@ -55,12 +92,44 @@ export async function runInteractiveCli(deps) {
             deps.writeOut('2. 올리브영');
             deps.writeOut('3. CU');
             deps.writeOut('4. 롯데시네마');
-            const serviceChoice = await askMenu(prompt, '서비스 번호를 선택하세요 (0: 종료):', [
-                '다이소',
-                '올리브영',
-                'CU',
-                '롯데시네마',
-            ]);
+            const serviceChoice = await askServiceChoice(prompt, deps.writeOut);
+            if (typeof serviceChoice === 'string') {
+                const intent = inferDaisoFreeTextIntent(serviceChoice);
+                deps.writeOut('자유 입력을 다이소 조회로 처리합니다.');
+                deps.writeOut(`- 상품 키워드: ${intent.productQuery}`);
+                deps.writeOut(`- 위치 키워드: ${intent.storeKeyword}`);
+                const storeResult = await fetchStoresWithKeywordFallback(deps.fetchImpl, 'daiso', intent.storeKeyword);
+                const stores = storeResult.stores;
+                if (stores.length === 0) {
+                    deps.writeOut('검색된 매장이 없습니다.');
+                    deps.writeOut('힌트: "안산 중앙역" 대신 "안산중앙" 또는 "고잔"으로 검색해보세요.');
+                    keepRunning = await askYesNo(prompt, '다시 시도할까요? (y/n): ');
+                    continue;
+                }
+                const selectedStore = stores.length === 1
+                    ? stores[0]
+                    : await pickFromList({
+                        prompt,
+                        writeOut: deps.writeOut,
+                        title: '[매장 선택]',
+                        emptyText: '검색된 매장이 없습니다.',
+                        cancelText: '매장 검색으로 돌아갑니다.',
+                        items: stores,
+                        renderItem: (store, index) => `${index + 1}. ${store.name} | ${store.address || '주소 정보 없음'}`,
+                        filterText: (store) => `${store.name} ${store.address} ${store.phone}`,
+                        indexText: '입력: 번호 선택 | /키워드 필터 | all 전체보기 | 0 다시 검색',
+                    });
+                if (!selectedStore) {
+                    continue;
+                }
+                printStoreDetail(deps.writeOut, selectedStore);
+                await runDaisoItemSearch(deps, prompt, selectedStore, intent.productQuery);
+                const nextAction = await askNextAction(prompt, deps.writeOut);
+                if (nextAction === 'exit') {
+                    keepRunning = false;
+                }
+                continue;
+            }
             if (serviceChoice === 0) {
                 break;
             }

package/dist/cliPicker.js

@@ -49,6 +49,7 @@ export async function pickFromList(options) {
         }
         const picked = Number.parseInt(answer, 10);
         if (Number.isNaN(picked) || picked < 1 || picked > visibleItems.length) {
+            writeOut(`번호로 입력하세요. 1부터 ${visibleItems.length} 사이에서 선택하거나 0으로 취소하세요.`);
             continue;
         }
         return visibleItems[picked - 1];

package/dist/cliRenderer.js

@@ -29,7 +29,17 @@ function formatMeta(meta) {
     return [`메타: ${pairs.join(', ')}`];
 }
 function detectName(item) {
-    const keys = ['name', 'productName', 'storeName', 'theaterName', 'movieName'];
+    const keys = [
+        'name',
+        'productName',
+        'goodsNm',
+        'goodsName',
+        'itemName',
+        'searchItemName',
+        'storeName',
+        'theaterName',
+        'movieName',
+    ];
     for (const key of keys) {
         if (typeof item[key] === 'string' && item[key].trim().length > 0) {
             return item[key];
@@ -49,8 +59,18 @@ function formatCollection(title, items) {
             continue;
         }
         const name = detectName(entry);
-        const id = entry.id ?? entry.productId ?? entry.PD_NO ?? entry.storeCode ?? entry.theaterId ?? entry.movieId;
-        const price = entry.price ?? entry.prc ?? entry.PD_PRC;
+        const id = entry.id ??
+            entry.productId ??
+            entry.PD_NO ??
+            entry.itemCode ??
+            entry.pluCd ??
+            entry.goodsNumber ??
+            entry.productNo ??
+            entry.storeCode ??
+            entry.bizNo ??
+            entry.theaterId ??
+            entry.movieId;
+        const price = entry.price ?? entry.prc ?? entry.PD_PRC ?? entry.viewPrice ?? entry.priceToPay ?? entry.searchItemSellPrice;
         let detail = `- ${name}`;
         if (id !== undefined) {
             detail += ` [${toText(id)}]`;
@@ -58,6 +78,22 @@ function formatCollection(title, items) {
         if (price !== undefined) {
             detail += ` / ${toText(price)}원`;
         }
+        const detailParts = [
+            entry.address ?? entry.storeAddress,
+            entry.distance !== undefined ? `${toText(entry.distance)}km` : undefined,
+            entry.distanceKm !== undefined ? `${toText(entry.distanceKm)}km` : undefined,
+            entry.distanceM !== undefined ? `${toText(entry.distanceM)}m` : undefined,
+            entry.quantity !== undefined ? `수량 ${toText(entry.quantity)}` : undefined,
+            entry.stock !== undefined ? `수량 ${toText(entry.stock)}` : undefined,
+            entry.realStockQuantity !== undefined ? `수량 ${toText(entry.realStockQuantity)}` : undefined,
+            entry.bizQty !== undefined ? `수량 ${toText(entry.bizQty)}` : undefined,
+            entry.remainQuantity !== undefined ? `수량 ${toText(entry.remainQuantity)}` : undefined,
+            entry.o2oRemainQuantity !== undefined ? `수량 ${toText(entry.o2oRemainQuantity)}` : undefined,
+            entry.stockLabel,
+        ].filter((value) => value !== undefined);
+        if (detailParts.length > 0) {
+            detail += ` / ${detailParts.map(toText).join(' / ')}`;
+        }
         lines.push(detail);
     }
     if (items.length > preview.length) {
@@ -65,6 +101,47 @@ function formatCollection(title, items) {
     }
     return lines;
 }
+function formatNestedInventory(data) {
+    const lines = [];
+    if (isRecord(data.nearbyStores)) {
+        lines.push(...formatCollection('주변 매장', data.nearbyStores.stores));
+    }
+    if (isRecord(data.inventory)) {
+        lines.push(...formatCollection('재고 매장', data.inventory.stores));
+        lines.push(...formatCollection('재고 항목', data.inventory.items));
+        lines.push(...formatCollection('재고 상품', data.inventory.products));
+        if (Array.isArray(data.inventory.products)) {
+            for (const product of data.inventory.products.slice(0, 3)) {
+                if (!isRecord(product) || !isRecord(product.storeInventory)) {
+                    continue;
+                }
+                lines.push(...formatCollection('상품별 매장 재고', product.storeInventory.stores));
+            }
+        }
+    }
+    return lines;
+}
+function formatDisplayLocation(data) {
+    const lines = [`진열 위치: ${data.hasLocation === true ? '있음' : '없음'}`];
+    if (!Array.isArray(data.locations) || data.locations.length === 0) {
+        return lines;
+    }
+    lines.push(`위치 목록: ${data.locations.length}건`);
+    for (const location of data.locations.slice(0, 5)) {
+        if (!isRecord(location)) {
+            lines.push(`- ${toText(location)}`);
+            continue;
+        }
+        const zoneNo = toText(location.zoneNo);
+        const stairNo = toText(location.stairNo);
+        const storeErp = location.storeErp !== undefined ? ` / storeErp ${toText(location.storeErp)}` : '';
+        lines.push(`- 구역 ${zoneNo} / 층 ${stairNo}${storeErp}`);
+    }
+    if (data.locations.length > 5) {
+        lines.push(`...외 ${data.locations.length - 5}건`);
+    }
+    return lines;
+}
 function formatProductDetail(data) {
     const id = data.id ?? data.productId ?? '-';
     const name = data.name ?? data.productName ?? '-';
@@ -113,10 +190,16 @@ export function renderApiEnvelope(command, url, payload) {
     else if (command === 'inventory') {
         lines.push(...formatInventory(data));
     }
+    else if (command === 'display-location') {
+        lines.push(...formatDisplayLocation(data));
+    }
     else if (command === 'cu-inventory') {
         lines.push(...formatCollection('매장 목록', isRecord(data.nearbyStores) ? data.nearbyStores.stores : undefined));
         lines.push(...formatCollection('재고 항목', isRecord(data.inventory) ? data.inventory.items : undefined));
     }
+    else if (command.endsWith('-inventory')) {
+        lines.push(...formatNestedInventory(data));
+    }
     else {
         lines.push(...formatCollection('제품 목록', data.products));
         lines.push(...formatCollection('매장 목록', data.stores));

package/dist/core/errors.js

@@ -0,0 +1,66 @@
+/**
+ * MCP/API 공통 에러 진단 구조
+ */
+const SERVICE_PREFIXES = [
+    'daiso',
+    'gs25',
+    'seveneleven',
+    'cu',
+    'emart24',
+    'lottemart',
+    'megabox',
+    'lottecinema',
+    'cgv',
+    'oliveyoung',
+];
+function normalizeService(value) {
+    return value.toLowerCase().replace(/_/g, '');
+}
+function toOperation(parts) {
+    const filtered = parts.filter((part) => part.length > 0 && part !== 'FAILED');
+    if (filtered.length === 0) {
+        return undefined;
+    }
+    return filtered.map((part) => part.toLowerCase()).join('_');
+}
+function inferServiceAndOperation(code) {
+    const parts = code.split('_').filter((part) => part.length > 0);
+    const normalizedFirst = normalizeService(parts[0] || '');
+    const service = SERVICE_PREFIXES.find((item) => normalizeService(item) === normalizedFirst);
+    if (!service) {
+        return { operation: toOperation(parts) };
+    }
+    return {
+        service,
+        operation: toOperation(parts.slice(1)),
+    };
+}
+function isRetryable(code, status) {
+    if (typeof status === 'number') {
+        return status >= 500 || status === 408 || status === 429;
+    }
+    const normalized = code.toUpperCase();
+    return normalized.includes('TIMEOUT') || normalized.includes('FAILED');
+}
+function buildHint(retryable) {
+    return retryable
+        ? '일시적인 외부 서비스 오류일 수 있습니다. 잠시 후 다시 시도하세요.'
+        : '입력값 또는 요청 조건을 확인하세요.';
+}
+export function toStandardErrorDiagnostics(code, message, options = {}) {
+    const inferred = inferServiceAndOperation(code);
+    const retryable = isRetryable(code, options.status || options.upstreamStatus);
+    return {
+        code,
+        message,
+        status: options.status,
+        retryable,
+        service: options.service || inferred.service,
+        operation: options.operation || inferred.operation,
+        upstreamStatus: options.upstreamStatus,
+        hint: buildHint(retryable),
+    };
+}
+export function getErrorMessage(error) {
+    return error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+}

package/dist/core/registry.js

@@ -3,6 +3,206 @@
  *
  * 서비스 프로바이더를 등록하고 MCP 서버에 도구를 연결합니다.
  */
+import * as z from 'zod';
+import { getErrorMessage, toStandardErrorDiagnostics } from './errors.js';
+const DEFAULT_OUTPUT_SCHEMA = z.object({}).loose().describe('도구 실행 결과(JSON 객체)');
+function createFallbackOutputSchema(toolName) {
+    if (toolName.includes('search_products') || toolName.includes('searchProducts') || toolName.endsWith('_products')) {
+        return {
+            keyword: z.string().optional(),
+            query: z.string().optional(),
+            page: z.number().optional(),
+            pageSize: z.number().optional(),
+            totalCount: z.number().optional(),
+            count: z.number().optional(),
+            products: z.array(z.unknown()).optional(),
+            note: z.string().optional(),
+        };
+    }
+    if (toolName.includes('find_stores') || toolName.includes('nearby_stores') || toolName.includes('search_stores')) {
+        return {
+            keyword: z.string().optional(),
+            searchParams: z.unknown().optional(),
+            location: z.unknown().optional(),
+            totalCount: z.number().optional(),
+            filteredCount: z.number().optional(),
+            count: z.number().optional(),
+            stores: z.array(z.unknown()).optional(),
+        };
+    }
+    if (toolName.includes('inventory')) {
+        return {
+            productId: z.string().optional(),
+            keyword: z.string().optional(),
+            itemCode: z.string().nullable().optional(),
+            location: z.unknown().optional(),
+            product: z.unknown().optional(),
+            onlineStock: z.number().optional(),
+            inventory: z.unknown().optional(),
+            storeInventory: z.unknown().optional(),
+        };
+    }
+    if (toolName.includes('display_location')) {
+        return {
+            productId: z.string().optional(),
+            storeCode: z.string().optional(),
+            displayLocation: z.unknown().optional(),
+            locations: z.array(z.unknown()).optional(),
+        };
+    }
+    if (toolName.includes('price_info')) {
+        return {
+            productId: z.string().optional(),
+            productName: z.string().optional(),
+            product: z.unknown().optional(),
+            price: z.number().optional(),
+        };
+    }
+    if (toolName.includes('theater')) {
+        return {
+            keyword: z.string().optional(),
+            location: z.unknown().optional(),
+            count: z.number().optional(),
+            theaters: z.array(z.unknown()).optional(),
+        };
+    }
+    if (toolName.includes('movie') || toolName.includes('now_showing')) {
+        return {
+            keyword: z.string().optional(),
+            playDate: z.string().optional(),
+            theaterCode: z.string().optional(),
+            count: z.number().optional(),
+            movies: z.array(z.unknown()).optional(),
+        };
+    }
+    if (toolName.includes('timetable') || toolName.includes('remaining_seats')) {
+        return {
+            playDate: z.string().optional(),
+            theaterCode: z.string().optional(),
+            movieCode: z.string().optional(),
+            count: z.number().optional(),
+            showtimes: z.array(z.unknown()).optional(),
+            seats: z.array(z.unknown()).optional(),
+        };
+    }
+    if (toolName.includes('popwords')) {
+        return {
+            label: z.string().optional(),
+            keywords: z.array(z.string()).optional(),
+            count: z.number().optional(),
+        };
+    }
+    if (toolName.includes('catalog')) {
+        return {
+            pages: z.array(z.unknown()).optional(),
+            issues: z.array(z.unknown()).optional(),
+            exhibitions: z.array(z.unknown()).optional(),
+            count: z.number().optional(),
+        };
+    }
+    return {};
+}
+function createToolOutputSchema(toolName, outputSchema) {
+    const schema = outputSchema || createFallbackOutputSchema(toolName);
+    if (Object.keys(schema).length === 0) {
+        return DEFAULT_OUTPUT_SCHEMA;
+    }
+    return z
+        .object({
+        ...schema,
+        standard: z.unknown().optional().describe('서비스 공통 상품/매장/영화관 정규화 결과'),
+    })
+        .loose();
+}
+function parseJsonText(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function firstNumber(...values) {
+    for (const value of values) {
+        if (typeof value === 'number' && Number.isFinite(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            const parsed = Number.parseFloat(value.replace(/km$/i, ''));
+            if (Number.isFinite(parsed)) {
+                return value.trim().toLowerCase().endsWith('km') ? Math.round(parsed * 1000) : parsed;
+            }
+        }
+    }
+    return null;
+}
+function normalizeProducts(products) {
+    return products
+        .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        .map((item) => ({
+        code: firstString(item.itemCode, item.productCode, item.pluCd, item.id, item.productNo),
+        name: firstString(item.itemName, item.shortItemName, item.goodsName, item.productName, item.movieName, item.name),
+        price: firstNumber(item.viewPrice, item.salePrice, item.sellPrice, item.price, item.originPrice, item.searchItemSellPrice),
+        imageUrl: firstString(item.imageUrl),
+        raw: item,
+    }));
+}
+function normalizeStores(stores) {
+    return stores
+        .filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        .map((item) => ({
+        code: firstString(item.storeCode, item.code, item.id),
+        name: firstString(item.storeName, item.name, item.theaterName),
+        address: firstString(item.address, item.storeAddress),
+        distanceMeters: firstNumber(item.distanceM, item.distanceMeters, item.distance),
+        raw: item,
+    }));
+}
+function withStandardCollections(payload) {
+    const standard = {};
+    if (Array.isArray(payload.products)) {
+        standard.products = normalizeProducts(payload.products);
+    }
+    if (Array.isArray(payload.stores)) {
+        standard.stores = normalizeStores(payload.stores);
+    }
+    if (Array.isArray(payload.theaters)) {
+        standard.theaters = normalizeStores(payload.theaters);
+    }
+    if (Array.isArray(payload.movies)) {
+        standard.movies = normalizeProducts(payload.movies);
+    }
+    if (Object.keys(standard).length === 0) {
+        return payload;
+    }
+    return {
+        ...payload,
+        standard,
+    };
+}
+function buildStructuredContent(result) {
+    if (result.structuredContent) {
+        return withStandardCollections(result.structuredContent);
+    }
+    const text = result.content[0]?.text || '';
+    const parsed = parseJsonText(text);
+    if (parsed) {
+        return withStandardCollections(parsed);
+    }
+    return { text };
+}
 /**
  * 서비스 레지스트리 클래스
  *
@@ -73,14 +273,38 @@ export class ServiceRegistry {
      * 단일 도구를 MCP 서버에 등록
      */
     registerTool(server, tool) {
-        server.registerTool(tool.name, tool.metadata, async (args) => {
-            const result = await tool.handler(args);
-            return {
+        const metadata = {
+            ...tool.metadata,
+            outputSchema: createToolOutputSchema(tool.name, tool.metadata.outputSchema),
+        };
+        server.registerTool(tool.name, metadata, async (args) => {
+            let result;
+            try {
+                result = await tool.handler(args);
+            }
+            catch (error) {
+                const message = getErrorMessage(error);
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: message }],
+                    structuredContent: {
+                        error: toStandardErrorDiagnostics('TOOL_EXECUTION_FAILED', message, {
+                            operation: tool.name,
+                        }),
+                    },
+                };
+            }
+            const response = {
                 content: result.content.map((item) => ({
                     type: item.type,
                     text: item.text,
                 })),
+                structuredContent: buildStructuredContent(result),
             };
+            if (result.isError) {
+                response.isError = true;
+            }
+            return response;
         });
     }
     /**

package/dist/index.js

@@ -34,6 +34,7 @@ import { registerEmart24Routes } from './api/routes/emart24Routes.js';
 import { registerGs25Routes } from './api/routes/gs25Routes.js';
 import { registerSevenElevenRoutes } from './api/routes/sevenelevenRoutes.js';
 import { registerHealthRoutes } from './api/routes/healthRoutes.js';
+import { buildConfigStatus } from './api/configStatus.js';
 // 서버 메타데이터
 const SERVER_NAME = 'multi-service-mcp';
 const SERVER_VERSION = '1.0.0';
@@ -196,7 +197,7 @@ app.on(['POST', 'DELETE', 'OPTIONS'], '/', async (c) => {
     return transport.handleRequest(c.req.raw);
 });
 // 헬스 체크 엔드포인트
-app.get('/health', (c) => c.json({ status: 'ok' }));
+app.get('/health', (c) => c.json({ status: 'ok', config: buildConfigStatus(c.env) }));
 registerHealthRoutes(app);
 // 프롬프트 페이지 (MCP 미지원 에이전트용)
 app.get('/prompt', (c) => {

package/dist/pages/openapiSpecActions.js

@@ -17,7 +17,7 @@ const ACTION_QUERY_PARAMETERS = [
     { name: 'q', in: 'query', required: false, description: '다이소 제품 검색어', schema: { type: 'string' } },
     { name: 'query', in: 'query', required: false, description: '세븐일레븐 상품 검색어', schema: { type: 'string' } },
     { name: 'itemCode', in: 'query', required: false, description: 'GS25 상품 코드', schema: { type: 'string' } },
-    { name: 'productId', in: 'query', required: false, description: '제품 ID 또는 상세 조회용 path 파라미터', schema: { type: 'string' } },
+    { name: 'productId', in: 'query', required: false, description: '제품 ID 또는 상세 조회용 path 파라미터. 상품명만 알면 먼저 daisoSearchProducts 또는 /api/daiso/products로 productId를 확인하세요.', schema: { type: 'string' } },
     { name: 'keyword', in: 'query', required: false, description: '공통 키워드 파라미터', schema: { type: 'string' } },
     { name: 'sido', in: 'query', required: false, description: '다이소 시/도', schema: { type: 'string' } },
     { name: 'gugun', in: 'query', required: false, description: '다이소 구/군', schema: { type: 'string' } },
@@ -37,8 +37,8 @@ const ACTION_QUERY_PARAMETERS = [
     { name: 'offset', in: 'query', required: false, description: 'CU 검색 오프셋', schema: { type: 'integer' } },
     { name: 'limit', in: 'query', required: false, description: '최대 결과 수', schema: { type: 'integer' } },
     { name: 'storeLimit', in: 'query', required: false, description: '매장 결과 제한 수', schema: { type: 'integer' } },
-    { name: 'storeCode', in: 'query', required: false, description: '매장 코드', schema: { type: 'string' } },
-    { name: 'storeName', in: 'query', required: false, description: '매장명', schema: { type: 'string' } },
+    { name: 'storeCode', in: 'query', required: false, description: '매장 코드. 다이소 진열 위치는 /api/daiso/inventory 응답의 storeInventory.stores[].storeCode에서 확인하세요.', schema: { type: 'string' } },
+    { name: 'storeName', in: 'query', required: false, description: '매장명. 롯데마트 상품 조회에서 storeCode가 없을 때 사용하며, 모르면 먼저 lottemartFindNearbyStores 또는 /api/lottemart/stores로 확인하세요.', schema: { type: 'string' } },
     { name: 'storeKeyword', in: 'query', required: false, description: '매장 키워드', schema: { type: 'string' } },
     { name: 'playDate', in: 'query', required: false, description: '상영일(YYYYMMDD)', schema: { type: 'string' } },
     { name: 'regionCode', in: 'query', required: false, description: 'CGV 지역 코드', schema: { type: 'string' } },

package/dist/pages/openapiSpecPathsCu.js

@@ -114,6 +114,13 @@ export const OPENAPI_PATHS_CU = {
                     description: '재고 정렬 방식',
                     schema: { type: 'string', default: 'recom' },
                 },
+                {
+                    name: 'storeCheck',
+                    in: 'query',
+                    required: false,
+                    description: 'false이면 주변 매장 조회를 생략하고 재고 상품 검색만 수행',
+                    schema: { type: 'boolean', default: true },
+                },
             ],
             responses: {
                 '200': {

package/dist/pages/openapiSpecPathsLotteMart.js

@@ -111,6 +111,20 @@ export const OPENAPI_PATHS_LOTTEMART = {
                     description: '추가 조회할 최대 페이지 수',
                     schema: { type: 'integer', default: 3, minimum: 1, maximum: 20 },
                 },
+                {
+                    name: 'source',
+                    in: 'query',
+                    required: false,
+                    description: '상품 검색 경로',
+                    schema: { type: 'string', enum: ['auto', 'legacy', 'zetta'], default: 'auto' },
+                },
+                {
+                    name: 'timeoutMs',
+                    in: 'query',
+                    required: false,
+                    description: '요청 제한 시간(ms)',
+                    schema: { type: 'integer', default: 45000, minimum: 1 },
+                },
             ],
             responses: {
                 '200': {