daiso 1.0.0

package/dist/cli.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * daiso CLI 엔트리
+ *
+ * npx daiso 명령으로 원격 MCP 서버 정보를 확인하고 상태를 점검합니다.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+const DEFAULT_BASE_URL = 'https://mcp.aka.page';
+const DEFAULT_MCP_URL = `${DEFAULT_BASE_URL}/mcp`;
+function loadVersion() {
+    const cliPath = fileURLToPath(import.meta.url);
+    const packagePath = path.resolve(path.dirname(cliPath), '../package.json');
+    if (!existsSync(packagePath)) {
+        return '0.0.0';
+    }
+    const raw = readFileSync(packagePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? '0.0.0';
+}
+function printHelp(writeOut) {
+    writeOut('daiso CLI');
+    writeOut('');
+    writeOut('사용법:');
+    writeOut('  daiso <command> [options]');
+    writeOut('');
+    writeOut('명령어:');
+    writeOut('  help                 도움말 출력');
+    writeOut('  version              CLI 버전 출력');
+    writeOut('  url                  MCP 엔드포인트 URL 출력');
+    writeOut('  health               원격 서버 상태 확인');
+    writeOut('  claude               Claude Code MCP 등록 명령 출력');
+    writeOut('  claude --exec        Claude Code MCP 등록 명령 실행');
+    writeOut('');
+    writeOut('예시:');
+    writeOut('  npx daiso url');
+    writeOut('  npx daiso health');
+    writeOut('  npx daiso claude');
+}
+async function execCommand(command, args) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            shell: false,
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 1);
+        });
+    });
+}
+function createDefaultDeps() {
+    return {
+        fetchImpl: fetch,
+        writeOut: (message) => {
+            process.stdout.write(`${message}\n`);
+        },
+        writeErr: (message) => {
+            process.stderr.write(`${message}\n`);
+        },
+        getVersion: loadVersion,
+        nowIso: () => new Date().toISOString(),
+        runCommand: execCommand,
+    };
+}
+export async function runCli(argv, deps) {
+    const resolvedDeps = {
+        ...createDefaultDeps(),
+        ...deps,
+    };
+    const [command, ...options] = argv;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        printHelp(resolvedDeps.writeOut);
+        return 0;
+    }
+    if (command === 'version' || command === '--version' || command === '-v') {
+        resolvedDeps.writeOut(resolvedDeps.getVersion());
+        return 0;
+    }
+    if (command === 'url') {
+        resolvedDeps.writeOut(DEFAULT_MCP_URL);
+        return 0;
+    }
+    if (command === 'health') {
+        try {
+            const response = await resolvedDeps.fetchImpl(`${DEFAULT_BASE_URL}/health`);
+            if (!response.ok) {
+                resolvedDeps.writeErr(`서버 상태 확인 실패: HTTP ${response.status}`);
+                return 1;
+            }
+            const payload = (await response.json());
+            resolvedDeps.writeOut(JSON.stringify({
+                status: payload.status ?? 'unknown',
+                endpoint: DEFAULT_MCP_URL,
+                checkedAt: resolvedDeps.nowIso(),
+            }, null, 2));
+            return 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            resolvedDeps.writeErr(`서버 상태 확인 중 오류 발생: ${message}`);
+            return 1;
+        }
+    }
+    if (command === 'claude') {
+        const cliArgs = ['mcp', 'add', 'daiso', DEFAULT_BASE_URL, '--transport', 'sse'];
+        if (options.includes('--exec')) {
+            try {
+                return await resolvedDeps.runCommand('claude', cliArgs);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                resolvedDeps.writeErr(`Claude CLI 실행 실패: ${message}`);
+                return 1;
+            }
+        }
+        resolvedDeps.writeOut(`claude ${cliArgs.join(' ')}`);
+        return 0;
+    }
+    resolvedDeps.writeErr(`알 수 없는 명령어: ${command}`);
+    resolvedDeps.writeErr('도움말: daiso help');
+    return 1;
+}
+export function isDirectExecution(entryPath = process.argv[1], moduleUrl = import.meta.url) {
+    if (!entryPath) {
+        return false;
+    }
+    return path.resolve(entryPath) === fileURLToPath(moduleUrl);
+}
+/* c8 ignore start */
+if (isDirectExecution()) {
+    runCli(process.argv.slice(2)).then((exitCode) => {
+        process.exit(exitCode);
+    });
+}
+/* c8 ignore stop */

package/dist/core/interfaces.js

@@ -0,0 +1,6 @@
+/**
+ * 서비스 프로바이더 인터페이스
+ *
+ * 모든 서비스(다이소, CU, CGV 등)가 구현해야 하는 계약입니다.
+ */
+export {};

package/dist/core/registry.js

@@ -0,0 +1,121 @@
+/**
+ * 서비스 레지스트리
+ *
+ * 서비스 프로바이더를 등록하고 MCP 서버에 도구를 연결합니다.
+ */
+/**
+ * 서비스 레지스트리 클래스
+ *
+ * 여러 서비스 프로바이더를 관리하고 MCP 서버에 등록합니다.
+ *
+ * @example
+ * ```typescript
+ * const registry = new ServiceRegistry();
+ * registry.register(createDaisoService);
+ * registry.register(createCuService);
+ * await registry.applyToServer(mcpServer);
+ * ```
+ */
+export class ServiceRegistry {
+    services = new Map();
+    /**
+     * 서비스 팩토리 등록
+     * @param factory 서비스 인스턴스를 생성하는 팩토리 함수
+     */
+    register(factory) {
+        const service = factory();
+        const { id } = service.metadata;
+        if (this.services.has(id)) {
+            throw new Error(`서비스 '${id}'가 이미 등록되어 있습니다.`);
+        }
+        this.services.set(id, service);
+    }
+    /**
+     * 여러 서비스 팩토리를 한 번에 등록
+     * @param factories 서비스 팩토리 함수 배열
+     */
+    registerAll(factories) {
+        for (const factory of factories) {
+            this.register(factory);
+        }
+    }
+    /**
+     * 모든 서비스 초기화
+     */
+    async initializeAll() {
+        const initPromises = Array.from(this.services.values())
+            .filter((service) => service.initialize)
+            .map((service) => service.initialize());
+        await Promise.all(initPromises);
+    }
+    /**
+     * 모든 서비스 정리
+     */
+    async cleanupAll() {
+        const cleanupPromises = Array.from(this.services.values())
+            .filter((service) => service.cleanup)
+            .map((service) => service.cleanup());
+        await Promise.all(cleanupPromises);
+    }
+    /**
+     * 모든 도구를 MCP 서버에 등록
+     * @param server MCP 서버 인스턴스
+     */
+    applyToServer(server) {
+        for (const service of this.services.values()) {
+            const tools = service.getTools();
+            for (const tool of tools) {
+                this.registerTool(server, tool);
+            }
+        }
+    }
+    /**
+     * 단일 도구를 MCP 서버에 등록
+     */
+    registerTool(server, tool) {
+        server.registerTool(tool.name, tool.metadata, async (args) => {
+            const result = await tool.handler(args);
+            return {
+                content: result.content.map((item) => ({
+                    type: item.type,
+                    text: item.text,
+                })),
+            };
+        });
+    }
+    /**
+     * 등록된 서비스 정보 목록 반환
+     * API 응답용으로 사용됩니다.
+     */
+    getServicesInfo() {
+        return Array.from(this.services.values()).map((service) => ({
+            id: service.metadata.id,
+            name: service.metadata.name,
+            version: service.metadata.version,
+            description: service.metadata.description,
+            tools: service.getTools().map((tool) => tool.name),
+        }));
+    }
+    /**
+     * 등록된 모든 도구 이름 반환
+     */
+    getAllToolNames() {
+        const toolNames = [];
+        for (const service of this.services.values()) {
+            toolNames.push(...service.getTools().map((tool) => tool.name));
+        }
+        return toolNames;
+    }
+    /**
+     * 서비스 개수 반환
+     */
+    get size() {
+        return this.services.size;
+    }
+    /**
+     * 특정 서비스 조회
+     */
+    getService(id) {
+        return this.services.get(id);
+    }
+}

package/dist/core/types.js

@@ -0,0 +1,6 @@
+/**
+ * 공통 타입 정의
+ *
+ * 모든 서비스 프로바이더가 사용하는 공통 타입입니다.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,123 @@
+/**
+ * 다중 서비스 MCP 서버
+ *
+ * Cloudflare Workers에서 실행되는 플러그인 기반 MCP 서버입니다.
+ * 다이소, 편의점, 백화점 등 다양한 서비스를 확장할 수 있습니다.
+ */
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { ServiceRegistry } from './core/registry.js';
+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 { createPromptResponse } from './pages/prompt.js';
+import { createOpenApiJsonResponse, createOpenApiYamlResponse } from './pages/openapi.js';
+import { createPrivacyResponse } from './pages/privacy.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';
+// 서버 메타데이터
+const SERVER_NAME = 'multi-service-mcp';
+const SERVER_VERSION = '1.0.0';
+/**
+ * 요청 컨텍스트 기반 서비스 레지스트리 생성
+ */
+const createRegistry = (bindings) => {
+    const registry = new ServiceRegistry();
+    registry.registerAll([
+        createDaisoService,
+        createMegaboxService,
+        () => createCgvService({
+            zyteApiKey: bindings?.ZYTE_API_KEY,
+        }),
+        () => createOliveyoungService({
+            zyteApiKey: bindings?.ZYTE_API_KEY,
+        }),
+    ]);
+    return registry;
+};
+/**
+ * MCP 서버 생성 함수
+ */
+const createMcpServer = (bindings) => {
+    const registry = createRegistry(bindings);
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    registry.applyToServer(server);
+    return server;
+};
+// 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'],
+    exposeHeaders: ['mcp-session-id', 'mcp-protocol-version'],
+}));
+// 기본 정보 엔드포인트 (GET 요청만)
+app.get('/', (c) => {
+    const registry = createRegistry(c.env);
+    const services = registry.getServicesInfo();
+    const allTools = registry.getAllToolNames();
+    return c.json({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+        description: 'Multi-Service MCP Server for Cloudflare Workers',
+        endpoints: {
+            mcp: '/ 또는 /mcp (POST) - MCP 프로토콜 엔드포인트',
+            health: '/health (GET) - 헬스 체크',
+        },
+        services,
+        tools: allTools,
+        totalServices: services.length,
+        totalTools: allTools.length,
+    });
+});
+// 루트 경로에서 MCP 요청 처리 (POST, DELETE, OPTIONS)
+app.on(['POST', 'DELETE', 'OPTIONS'], '/', async (c) => {
+    const transport = new WebStandardStreamableHTTPServerTransport();
+    const server = createMcpServer(c.env);
+    await server.connect(transport);
+    return transport.handleRequest(c.req.raw);
+});
+// 헬스 체크 엔드포인트
+app.get('/health', (c) => c.json({ status: 'ok' }));
+// 프롬프트 페이지 (MCP 미지원 에이전트용)
+app.get('/prompt', (c) => {
+    const baseUrl = new URL(c.req.url).origin;
+    return createPromptResponse(baseUrl);
+});
+// OpenAPI 스펙 엔드포인트 (ChatGPT GPTs 등록용)
+app.get('/openapi.json', (c) => {
+    const baseUrl = new URL(c.req.url).origin;
+    return createOpenApiJsonResponse(baseUrl);
+});
+app.get('/openapi.yaml', (c) => {
+    const baseUrl = new URL(c.req.url).origin;
+    return createOpenApiYamlResponse(baseUrl);
+});
+// 개인정보 처리방침 페이지
+app.get('/privacy', (c) => {
+    const baseUrl = new URL(c.req.url).origin;
+    return createPrivacyResponse(baseUrl);
+});
+// GET API 엔드포인트 (MCP 미지원 에이전트용)
+registerDaisoRoutes(app);
+registerOliveyoungRoutes(app);
+registerMegaboxRoutes(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);
+});
+export default app;

package/dist/pages/openapi.js

@@ -0,0 +1,6 @@
+/**
+ * OpenAPI 페이지 엔트리
+ */
+export { generateOpenApiSpec } from './openapiSpec.js';
+export { createOpenApiJsonResponse, createOpenApiYamlResponse } from './openapiResponse.js';
+export { __testOnlyJsonToYaml } from './openapiYaml.js';

package/dist/pages/openapiResponse.js

@@ -0,0 +1,32 @@
+/**
+ * OpenAPI 응답 생성 모듈
+ */
+import { generateOpenApiSpec } from './openapiSpec.js';
+import { jsonToYaml } from './openapiYaml.js';
+/**
+ * OpenAPI 스펙 응답 생성 (JSON)
+ */
+export function createOpenApiJsonResponse(baseUrl) {
+    const spec = generateOpenApiSpec(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 createOpenApiYamlResponse(baseUrl) {
+    const spec = generateOpenApiSpec(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

@@ -0,0 +1,43 @@
+/**
+ * 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,
+    };
+}