daiso 1.0.4 → 1.0.6

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

@@ -13,16 +13,34 @@ import { createDaisoService } from './services/daiso/index.js';
 import { createOliveyoungService } from './services/oliveyoung/index.js';
 import { createMegaboxService } from './services/megabox/index.js';
 import { createCgvService } from './services/cgv/index.js';
+import { createLotteCinemaService } from './services/lottecinema/index.js';
+import { createLotteMartService } from './services/lottemart/index.js';
+import { createCuService } from './services/cu/index.js';
+import { createEmart24Service } from './services/emart24/index.js';
+import { createGs25Service } from './services/gs25/index.js';
+import { createSevenElevenService } from './services/seveneleven/index.js';
 import { createPromptResponse } from './pages/prompt.js';
-import { createOpenApiJsonResponse, createOpenApiYamlResponse } from './pages/openapi.js';
+import { createFullOpenApiJsonResponse, createFullOpenApiYamlResponse, createOpenApiJsonResponse, createOpenApiYamlResponse, } from './pages/openapi.js';
 import { createPrivacyResponse } from './pages/privacy.js';
+import { buildActionQueryTargetUrl } from './api/actionsProxy.js';
 import { registerDaisoRoutes } from './api/routes/daisoRoutes.js';
 import { registerOliveyoungRoutes } from './api/routes/oliveyoungRoutes.js';
 import { registerMegaboxRoutes } from './api/routes/megaboxRoutes.js';
 import { registerCgvRoutes } from './api/routes/cgvRoutes.js';
+import { registerLotteCinemaRoutes } from './api/routes/lottecinemaRoutes.js';
+import { registerLotteMartRoutes } from './api/routes/lottemartRoutes.js';
+import { registerCuRoutes } from './api/routes/cuRoutes.js';
+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';
+const SESSION_HEADER = 'mcp-session-id';
+// 세션별 MCP 전송 계층/서버를 유지해 GET/POST/DELETE를 일관 처리합니다.
+const mcpSessions = new Map();
 /**
  * 요청 컨텍스트 기반 서비스 레지스트리 생성
  */
@@ -30,9 +48,21 @@ const createRegistry = (bindings) => {
     const registry = new ServiceRegistry();
     registry.registerAll([
         createDaisoService,
+        createGs25Service,
+        createSevenElevenService,
+        createCuService,
+        createEmart24Service,
+        () => createLotteMartService({
+            googleMapsApiKey: bindings?.GOOGLE_MAPS_API_KEY,
+            zyteApiKey: bindings?.ZYTE_API_KEY,
+        }),
         createMegaboxService,
+        () => createLotteCinemaService({
+            googleMapsApiKey: bindings?.GOOGLE_MAPS_API_KEY,
+        }),
         () => createCgvService({
             zyteApiKey: bindings?.ZYTE_API_KEY,
+            googleMapsApiKey: bindings?.GOOGLE_MAPS_API_KEY,
         }),
         () => createOliveyoungService({
             zyteApiKey: bindings?.ZYTE_API_KEY,
@@ -52,13 +82,88 @@ const createMcpServer = (bindings) => {
     registry.applyToServer(server);
     return server;
 };
+/**
+ * initialize 요청 여부를 확인합니다.
+ */
+const isInitializeRequest = (body) => {
+    if (Array.isArray(body)) {
+        return body.some((item) => typeof item === 'object' && item !== null && item.method === 'initialize');
+    }
+    return typeof body === 'object' && body !== null && body.method === 'initialize';
+};
+/**
+ * 새 세션 transport/server를 생성합니다.
+ */
+const createSessionTransport = (bindings) => {
+    const server = createMcpServer(bindings);
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto.randomUUID(),
+        onsessioninitialized: (sessionId) => {
+            mcpSessions.set(sessionId, { server, transport });
+        },
+        onsessionclosed: (sessionId) => {
+            mcpSessions.delete(sessionId);
+        },
+    });
+    return { server, transport };
+};
+/**
+ * /mcp 요청을 세션 기반으로 처리합니다.
+ */
+const handleMcpRequest = async (c) => {
+    const sessionId = c.req.header(SESSION_HEADER);
+    if (sessionId) {
+        const existing = mcpSessions.get(sessionId);
+        if (!existing) {
+            if (c.req.method === 'POST') {
+                const transport = new WebStandardStreamableHTTPServerTransport();
+                const server = createMcpServer(c.env);
+                await server.connect(transport);
+                const response = await transport.handleRequest(c.req.raw);
+                response.headers.set('x-mcp-session-fallback', 'stateless');
+                return response;
+            }
+            return c.json({
+                error: 'Session not found',
+                message: '유효하지 않은 mcp-session-id 입니다. initialize 요청부터 다시 시작해주세요.',
+            }, 404);
+        }
+        return existing.transport.handleRequest(c.req.raw);
+    }
+    if (c.req.method === 'POST') {
+        const parsedBody = await c.req.raw
+            .clone()
+            .json()
+            .catch(() => undefined);
+        if (!isInitializeRequest(parsedBody)) {
+            return c.json({
+                error: 'Bad Request',
+                message: '세션이 없습니다. 먼저 initialize 요청으로 세션을 생성해주세요.',
+            }, 400);
+        }
+        const { server, transport } = createSessionTransport(c.env);
+        await server.connect(transport);
+        return transport.handleRequest(c.req.raw, { parsedBody });
+    }
+    return c.json({
+        error: 'Bad Request',
+        message: `세션이 없습니다. 먼저 POST /mcp initialize 요청 후 ${SESSION_HEADER} 헤더를 사용해주세요.`,
+    }, 400);
+};
 // Hono 앱 생성
 const app = new Hono();
 // CORS 설정
 app.use('*', cors({
     origin: '*',
     allowMethods: ['GET', 'POST', 'DELETE', 'OPTIONS'],
-    allowHeaders: ['Content-Type', 'mcp-session-id', 'Last-Event-ID', 'mcp-protocol-version'],
+    allowHeaders: [
+        'Content-Type',
+        'Authorization',
+        'x-health-check-key',
+        'mcp-session-id',
+        'Last-Event-ID',
+        'mcp-protocol-version',
+    ],
     exposeHeaders: ['mcp-session-id', 'mcp-protocol-version'],
 }));
 // 기본 정보 엔드포인트 (GET 요청만)
@@ -73,6 +178,10 @@ app.get('/', (c) => {
         endpoints: {
             mcp: '/ 또는 /mcp (POST) - MCP 프로토콜 엔드포인트',
             health: '/health (GET) - 헬스 체크',
+            healthChecks: '/api/health/checks (GET) - 서비스별 상세 헬스 체크',
+            openapi: '/openapi.json (GET) - OpenAI Actions용 축약 OpenAPI',
+            openapiFull: '/openapi-full.json (GET) - 전체 OpenAPI',
+            actionsQuery: '/api/actions/query (GET) - 기존 GET API 통합 facade',
         },
         services,
         tools: allTools,
@@ -88,7 +197,8 @@ 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) => {
     const baseUrl = new URL(c.req.url).origin;
@@ -103,6 +213,14 @@ app.get('/openapi.yaml', (c) => {
     const baseUrl = new URL(c.req.url).origin;
     return createOpenApiYamlResponse(baseUrl);
 });
+app.get('/openapi-full.json', (c) => {
+    const baseUrl = new URL(c.req.url).origin;
+    return createFullOpenApiJsonResponse(baseUrl);
+});
+app.get('/openapi-full.yaml', (c) => {
+    const baseUrl = new URL(c.req.url).origin;
+    return createFullOpenApiYamlResponse(baseUrl);
+});
 // 개인정보 처리방침 페이지
 app.get('/privacy', (c) => {
     const baseUrl = new URL(c.req.url).origin;
@@ -110,14 +228,36 @@ app.get('/privacy', (c) => {
 });
 // GET API 엔드포인트 (MCP 미지원 에이전트용)
 registerDaisoRoutes(app);
+registerGs25Routes(app);
+registerSevenElevenRoutes(app);
+registerCuRoutes(app);
+registerEmart24Routes(app);
+registerLotteMartRoutes(app);
 registerOliveyoungRoutes(app);
 registerMegaboxRoutes(app);
+registerLotteCinemaRoutes(app);
 registerCgvRoutes(app);
-// MCP 엔드포인트
-app.all('/mcp', async (c) => {
-    const transport = new WebStandardStreamableHTTPServerTransport();
-    const server = createMcpServer(c.env);
-    await server.connect(transport);
-    return transport.handleRequest(c.req.raw);
+app.get('/api/actions/query', async (c) => {
+    try {
+        const targetUrl = buildActionQueryTargetUrl(c.req.url);
+        const headers = new Headers(c.req.raw.headers);
+        headers.delete('host');
+        return app.fetch(new Request(targetUrl.toString(), {
+            method: 'GET',
+            headers,
+        }), c.env);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.';
+        return c.json({
+            success: false,
+            error: {
+                code: 'INVALID_ACTION_QUERY',
+                message,
+            },
+        }, 400);
+    }
 });
+// MCP 엔드포인트
+app.all('/mcp', handleMcpRequest);
 export default app;

package/dist/pages/openapi.js

@@ -2,5 +2,6 @@
  * OpenAPI 페이지 엔트리
  */
 export { generateOpenApiSpec } from './openapiSpec.js';
-export { createOpenApiJsonResponse, createOpenApiYamlResponse } from './openapiResponse.js';
+export { generateFullOpenApiSpec } from './openapiFullSpec.js';
+export { createOpenApiJsonResponse, createOpenApiYamlResponse, createFullOpenApiJsonResponse, createFullOpenApiYamlResponse, } from './openapiResponse.js';
 export { __testOnlyJsonToYaml } from './openapiYaml.js';

package/dist/pages/openapiFullSpec.js

@@ -0,0 +1,58 @@
+/**
+ * 전체 OpenAPI 스펙 조합 모듈
+ */
+import { OPENAPI_PATHS_DAISO_OLIVEYOUNG } from './openapiSpecPathsDaisoOliveyoung.js';
+import { OPENAPI_PATHS_CU } from './openapiSpecPathsCu.js';
+import { OPENAPI_PATHS_EMART24 } from './openapiSpecPathsEmart24.js';
+import { OPENAPI_PATHS_LOTTEMART } from './openapiSpecPathsLotteMart.js';
+import { OPENAPI_PATHS_MEGABOX } from './openapiSpecPathsMegabox.js';
+import { OPENAPI_PATHS_CGV } from './openapiSpecPathsCgv.js';
+import { OPENAPI_PATHS_LOTTECINEMA } from './openapiSpecPathsLottecinema.js';
+import { OPENAPI_PATHS_GS25 } from './openapiSpecPathsGs25.js';
+import { OPENAPI_PATHS_SEVENELEVEN } from './openapiSpecPathsSeveneleven.js';
+import { OPENAPI_COMPONENTS } from './openapiSpecComponents.js';
+export function generateFullOpenApiSpec(baseUrl) {
+    return {
+        openapi: '3.1.0',
+        info: {
+            title: '다이소 MCP API (전체 스펙)',
+            description: `다이소 제품 검색, 매장 찾기, 재고 확인을 위한 API입니다.
+
+## 주요 기능
+- 🔍 **제품 검색**: 키워드로 다이소 제품 검색
+- 🏪 **매장 찾기**: 지역/키워드로 매장 검색
+- 📦 **재고 확인**: 온라인 및 오프라인 매장 재고 조회
+- 🧭 **진열 위치 조회**: 매장 내 상품 구역/층 정보 조회
+- 🏪 **GS25 매장/상품/재고 조회**: GS25 매장 탐색, 상품 검색, 재고 조회
+- 7️⃣ **세븐일레븐 상품/매장/재고 조회**: 상품 검색, 매장 검색, 실재고 조회
+- 🏪 **CU 매장/재고 조회**: CU 매장 탐색 및 상품 재고 검색
+- 🎬 **메가박스 지점/영화 조회**: 주변 지점, 상영 목록, 잔여 좌석 조회
+- 🎞️ **롯데시네마 지점/영화 조회**: 주변 지점, 상영 목록, 잔여 좌석 조회
+- 🎥 **CGV 지점/영화 조회**: 극장 목록, 영화 목록, 시간표 조회
+
+## 사용 팁
+1. 한글 검색어는 URL 인코딩이 자동 처리됩니다
+2. 재고 확인 시 먼저 제품 검색으로 제품 ID를 확인하세요
+3. 위치 기반 재고 조회 시 lat, lng 파라미터를 활용하세요
+4. 세븐일레븐 재고 조회는 keyword와 storeKeyword를 함께 사용하면 정확도가 높아집니다`,
+            version: '1.0.0',
+            contact: {
+                name: 'GitHub Repository',
+                url: 'https://github.com/hmmhmmhm/daiso-mcp',
+            },
+        },
+        servers: [{ url: baseUrl, description: 'Production Server' }],
+        paths: {
+            ...OPENAPI_PATHS_DAISO_OLIVEYOUNG,
+            ...OPENAPI_PATHS_CU,
+            ...OPENAPI_PATHS_EMART24,
+            ...OPENAPI_PATHS_LOTTEMART,
+            ...OPENAPI_PATHS_GS25,
+            ...OPENAPI_PATHS_SEVENELEVEN,
+            ...OPENAPI_PATHS_MEGABOX,
+            ...OPENAPI_PATHS_LOTTECINEMA,
+            ...OPENAPI_PATHS_CGV,
+        },
+        components: OPENAPI_COMPONENTS,
+    };
+}

package/dist/pages/openapiResponse.js

@@ -2,6 +2,7 @@
  * OpenAPI 응답 생성 모듈
  */
 import { generateOpenApiSpec } from './openapiSpec.js';
+import { generateFullOpenApiSpec } from './openapiFullSpec.js';
 import { jsonToYaml } from './openapiYaml.js';
 /**
  * OpenAPI 스펙 응답 생성 (JSON)
@@ -30,3 +31,30 @@ export function createOpenApiYamlResponse(baseUrl) {
         },
     });
 }
+/**
+ * 전체 OpenAPI 스펙 응답 생성 (JSON)
+ */
+export function createFullOpenApiJsonResponse(baseUrl) {
+    const spec = generateFullOpenApiSpec(baseUrl);
+    return new Response(JSON.stringify(spec, null, 2), {
+        headers: {
+            'Content-Type': 'application/json; charset=utf-8',
+            'Cache-Control': 'public, max-age=3600',
+            'Access-Control-Allow-Origin': '*',
+        },
+    });
+}
+/**
+ * 전체 OpenAPI 스펙 응답 생성 (YAML)
+ */
+export function createFullOpenApiYamlResponse(baseUrl) {
+    const spec = generateFullOpenApiSpec(baseUrl);
+    const yaml = jsonToYaml(spec);
+    return new Response(yaml, {
+        headers: {
+            'Content-Type': 'text/yaml; charset=utf-8',
+            'Cache-Control': 'public, max-age=3600',
+            'Access-Control-Allow-Origin': '*',
+        },
+    });
+}

package/dist/pages/openapiSpec.js

@@ -1,43 +1,4 @@
 /**
- * OpenAPI 스펙 조합 모듈
+ * OpenAI Actions용 기본 OpenAPI 스펙 엔트리
  */
-import { OPENAPI_PATHS_DAISO_OLIVEYOUNG } from './openapiSpecPathsDaisoOliveyoung.js';
-import { OPENAPI_PATHS_MEGABOX } from './openapiSpecPathsMegabox.js';
-import { OPENAPI_PATHS_CGV } from './openapiSpecPathsCgv.js';
-import { OPENAPI_COMPONENTS } from './openapiSpecComponents.js';
-/**
- * OpenAPI 스펙 생성
- */
-export function generateOpenApiSpec(baseUrl) {
-    return {
-        openapi: '3.1.0',
-        info: {
-            title: '다이소 MCP API',
-            description: `다이소 제품 검색, 매장 찾기, 재고 확인을 위한 API입니다.
-
-## 주요 기능
-- 🔍 **제품 검색**: 키워드로 다이소 제품 검색
-- 🏪 **매장 찾기**: 지역/키워드로 매장 검색
-- 📦 **재고 확인**: 온라인 및 오프라인 매장 재고 조회
-- 🎬 **메가박스 지점/영화 조회**: 주변 지점, 상영 목록, 잔여 좌석 조회
-- 🎥 **CGV 지점/영화 조회**: 극장 목록, 영화 목록, 시간표 조회
-
-## 사용 팁
-1. 한글 검색어는 URL 인코딩이 자동 처리됩니다
-2. 재고 확인 시 먼저 제품 검색으로 제품 ID를 확인하세요
-3. 위치 기반 재고 조회 시 lat, lng 파라미터를 활용하세요`,
-            version: '1.0.0',
-            contact: {
-                name: 'GitHub Repository',
-                url: 'https://github.com/hmmhmmhm/daiso-mcp',
-            },
-        },
-        servers: [{ url: baseUrl, description: 'Production Server' }],
-        paths: {
-            ...OPENAPI_PATHS_DAISO_OLIVEYOUNG,
-            ...OPENAPI_PATHS_MEGABOX,
-            ...OPENAPI_PATHS_CGV,
-        },
-        components: OPENAPI_COMPONENTS,
-    };
-}
+export { generateOpenApiSpec } from './openapiSpecActions.js';