coupon-moa-mcp 0.0.1

package/README.md

@@ -0,0 +1,61 @@
+# coupon-moa-mcp
+
+Coupon Moa 어드민 MCP Server. Claude Desktop 또는 Claude Code에서 어드민 데이터를 조회하고, 지점을 일괄 등록할 수 있습니다.
+
+## 설치 및 사용
+
+### Claude Desktop
+
+`claude_desktop_config.json`에 추가:
+
+```json
+{
+  "mcpServers": {
+    "coupon-moa": {
+      "command": "npx",
+      "args": ["-y", "coupon-moa-mcp"],
+      "env": {
+        "ADMIN_API_URL": "https://your-api-url.com"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+`.mcp.json`에 추가:
+
+```json
+{
+  "mcpServers": {
+    "coupon-moa": {
+      "command": "npx",
+      "args": ["-y", "coupon-moa-mcp"],
+      "env": {
+        "ADMIN_API_URL": "https://your-api-url.com"
+      }
+    }
+  }
+}
+```
+
+## 인증
+
+처음 실행 시 브라우저가 열리면서 Google 로그인을 요청합니다. 로그인 완료 후 토큰이 `~/.coupon-moa-mcp/token.json`에 저장되며, 이후 자동으로 사용됩니다.
+
+## Tools
+
+| Tool | 설명 |
+|------|------|
+| `admin:push-stores` | 지점 데이터를 어드민 웹에 미리보기로 push |
+| `admin:list-stores` | 지점 목록 조회 |
+| `admin:list-brands` | 브랜드 목록 조회 |
+| `admin:list-cities` | 도시 목록 조회 |
+| `admin:get-review-status` | 검토 진행 상태 조회 |
+
+## 환경변수
+
+| 변수 | 설명 | 기본값 |
+|------|------|--------|
+| `ADMIN_API_URL` | 백엔드 API URL | `http://localhost:8080` |

package/bin/coupon-moa-mcp.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+register('tsx/esm', pathToFileURL('./'));
+
+const { default: _ } = await import('../src/index.ts');

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "coupon-moa-mcp",
+  "version": "0.0.1",
+  "description": "MCP server for Coupon Moa admin — push store data, query brands/cities/stores via Claude",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "coupon-moa-mcp": "./bin/coupon-moa-mcp.mjs"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "tsx src/index.ts",
+    "publish:npm": "bash ../../scripts/publish-mcp.sh"
+  },
+  "files": [
+    "src/**/*.ts",
+    "bin/**/*.mjs",
+    "package.json",
+    "README.md"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "coupon-moa",
+    "claude"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "tsx": "^4.19.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,133 @@
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const TOKEN_DIR = join(homedir(), '.coupon-moa-mcp');
+const TOKEN_FILE = join(TOKEN_DIR, 'token.json');
+const AUTH_PORT = 9401;
+
+interface StoredTokens {
+  accessToken: string;
+  refreshToken?: string;
+  savedAt: number;
+}
+
+export async function getAccessToken(apiUrl: string): Promise<string> {
+  // 저장된 토큰 확인
+  const stored = await loadTokens();
+  if (stored) {
+    // accessToken 유효성은 API 호출 시 확인 — 여기서는 일단 반환
+    return stored.accessToken;
+  }
+
+  // 토큰 없으면 OAuth 로그인
+  console.error('[MCP] 로그인이 필요합니다. 브라우저가 열립니다...');
+  const tokens = await startOAuthFlow(apiUrl);
+  await saveTokens(tokens);
+  return tokens.accessToken;
+}
+
+export async function refreshAccessToken(apiUrl: string): Promise<string | null> {
+  const stored = await loadTokens();
+  if (!stored?.refreshToken) {
+    return null;
+  }
+
+  try {
+    const response = await fetch(`${apiUrl}/api/auth/refresh`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'Cookie': `refreshToken=${stored.refreshToken}` },
+    });
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = await response.json() as { data?: { accessToken: string } };
+    const accessToken = data.data?.accessToken;
+    if (!accessToken) {
+      return null;
+    }
+
+    await saveTokens({ ...stored, accessToken, savedAt: Date.now() });
+    return accessToken;
+  } catch {
+    return null;
+  }
+}
+
+export async function clearTokens(): Promise<void> {
+  if (existsSync(TOKEN_FILE)) {
+    const { unlink } = await import('node:fs/promises');
+    await unlink(TOKEN_FILE);
+  }
+}
+
+async function loadTokens(): Promise<StoredTokens | null> {
+  try {
+    const content = await readFile(TOKEN_FILE, 'utf-8');
+    return JSON.parse(content) as StoredTokens;
+  } catch {
+    return null;
+  }
+}
+
+async function saveTokens(tokens: StoredTokens): Promise<void> {
+  if (!existsSync(TOKEN_DIR)) {
+    await mkdir(TOKEN_DIR, { recursive: true });
+  }
+  await writeFile(TOKEN_FILE, JSON.stringify(tokens, null, 2));
+}
+
+function startOAuthFlow(apiUrl: string): Promise<StoredTokens> {
+  return new Promise((resolve, reject) => {
+    const server = createServer((req: IncomingMessage, res: ServerResponse) => {
+      const url = new URL(req.url ?? '', `http://localhost:${AUTH_PORT}`);
+
+      if (url.pathname === '/callback') {
+        const accessToken = url.searchParams.get('accessToken');
+
+        if (!accessToken) {
+          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end('<h1>인증 실패</h1><p>토큰을 받지 못했습니다. 다시 시도해주세요.</p>');
+          server.close();
+          reject(new Error('No access token received'));
+          return;
+        }
+
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end('<h1>인증 완료!</h1><p>이 창을 닫아도 됩니다.</p><script>setTimeout(()=>window.close(),1500)</script>');
+
+        server.close();
+        resolve({ accessToken, savedAt: Date.now() });
+        return;
+      }
+
+      res.writeHead(404);
+      res.end('Not found');
+    });
+
+    server.listen(AUTH_PORT, () => {
+      const loginUrl = `${apiUrl}/api/auth/google?redirect=http://localhost:${AUTH_PORT}`;
+      console.error(`[MCP] 브라우저에서 로그인해주세요: ${loginUrl}`);
+
+      // 브라우저 자동 열기
+      import('node:child_process').then(({ exec }) => {
+        const command = process.platform === 'darwin'
+          ? `open "${loginUrl}"`
+          : process.platform === 'win32'
+            ? `start "${loginUrl}"`
+            : `xdg-open "${loginUrl}"`;
+        exec(command);
+      });
+    });
+
+    // 60초 타임아웃
+    setTimeout(() => {
+      server.close();
+      reject(new Error('로그인 타임아웃 (60초). 다시 시도해주세요.'));
+    }, 60000);
+  });
+}

package/src/index.ts

@@ -0,0 +1,108 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { AdminApiClient } from './ws/ws-server.js';
+import { pushStoresSchema, pushStores } from './tools/push-stores.js';
+import {
+  listStoresSchema, listBrandsSchema, listCitiesSchema, getReviewStatusSchema,
+  listStores, listBrands, listCities, getReviewStatus,
+} from './tools/list-queries.js';
+
+const api = new AdminApiClient();
+await api.initialize();
+
+const server = new McpServer({
+  name: 'coupon-moa-admin',
+  version: '0.0.1',
+});
+
+// --- Tool: push-stores ---
+server.tool(
+  'admin:push-stores',
+  '지점 데이터를 어드민 웹에 미리보기로 push합니다. DB에 저장하지 않습니다. 사용자가 검토 후 등록합니다.',
+  pushStoresSchema.shape,
+  async (params) => {
+    try {
+      const result = await pushStores(api, params as any);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+  },
+);
+
+// --- Tool: list-stores ---
+server.tool(
+  'admin:list-stores',
+  '어드민에 등록된 지점 목록을 조회합니다.',
+  listStoresSchema.shape,
+  async (params) => {
+    try {
+      const result = await listStores(api, params as any);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+  },
+);
+
+// --- Tool: list-brands ---
+server.tool(
+  'admin:list-brands',
+  '어드민에 등록된 브랜드 목록을 조회합니다.',
+  listBrandsSchema.shape,
+  async (params) => {
+    try {
+      const result = await listBrands(api, params as any);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+  },
+);
+
+// --- Tool: list-cities ---
+server.tool(
+  'admin:list-cities',
+  '어드민에 등록된 도시 목록을 조회합니다.',
+  listCitiesSchema.shape,
+  async (params) => {
+    try {
+      const result = await listCities(api, params as any);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+  },
+);
+
+// --- Tool: get-review-status ---
+server.tool(
+  'admin:get-review-status',
+  '현재 진행 중인 일괄 등록 검토 상태를 조회합니다.',
+  getReviewStatusSchema.shape,
+  async () => {
+    try {
+      const result = await getReviewStatus(api);
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      return { content: [{ type: 'text', text: `Error: ${message}` }], isError: true };
+    }
+  },
+);
+
+// --- Start ---
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[MCP] Server started (API mode)');
+}
+
+main().catch((error) => {
+  console.error('[MCP] Fatal error:', error);
+  process.exit(1);
+});

package/src/tools/list-queries.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import type { AdminApiClient } from '../ws/ws-server.js';
+
+export const listStoresSchema = z.object({
+  brandId: z.string().optional().describe('브랜드 ID 필터'),
+  cityId: z.string().optional().describe('도시 ID 필터'),
+  state: z.string().optional().default('ENABLED').describe('상태 필터 (ENABLED, DISABLED, PENDING)'),
+  query: z.string().optional().describe('지점명/주소 검색어'),
+  limit: z.number().optional().default(50).describe('최대 결과 수 (기본 50)'),
+});
+
+export const listBrandsSchema = z.object({
+  state: z.string().optional().default('ENABLED').describe('상태 필터'),
+  query: z.string().optional().describe('브랜드명 검색어'),
+});
+
+export const listCitiesSchema = z.object({
+  state: z.string().optional().default('ENABLED').describe('상태 필터'),
+});
+
+export const getReviewStatusSchema = z.object({});
+
+export async function listStores(api: AdminApiClient, params: z.infer<typeof listStoresSchema>) {
+  return api.send('list-stores', params);
+}
+
+export async function listBrands(api: AdminApiClient, params: z.infer<typeof listBrandsSchema>) {
+  return api.send('list-brands', params);
+}
+
+export async function listCities(api: AdminApiClient, params: z.infer<typeof listCitiesSchema>) {
+  return api.send('list-cities', params);
+}
+
+export async function getReviewStatus(api: AdminApiClient) {
+  return api.send('get-review-status', {});
+}

package/src/tools/push-stores.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import type { AdminApiClient } from '../ws/ws-server.js';
+
+export const pushStoresSchema = z.object({
+  items: z.array(z.object({
+    brandId: z.string().describe('브랜드 ID'),
+    branchName: z.string().describe('한국어 지점명'),
+    nameJa: z.string().describe('일본어 지점명 (Google Places 검색용)'),
+    cityId: z.string().describe('도시 ID'),
+    address: z.string().optional().default('').describe('주소'),
+    location: z.tuple([z.number(), z.number()]).optional().default([0, 0]).describe('[lng, lat]'),
+    operatingHours: z.array(z.object({
+      day: z.number(),
+      open: z.string(),
+      close: z.string(),
+      isNextDay: z.boolean(),
+    })).optional().default([]).describe('영업시간'),
+    phone: z.string().optional().default('').describe('전화번호'),
+    note: z.string().optional().default('').describe('메모'),
+    warning: z.string().optional().default('').describe('주의사항'),
+  })).describe('등록할 지점 목록'),
+});
+
+export async function pushStores(api: AdminApiClient, params: z.infer<typeof pushStoresSchema>) {
+  const batchId = `batch-${crypto.randomUUID().slice(0, 8)}`;
+
+  const items = params.items.map((item) => {
+    const operatingHours = item.operatingHours.length > 0
+      ? item.operatingHours
+      : Array.from({ length: 7 }, (_, day) => ({
+          day,
+          open: '10:00',
+          close: '22:00',
+          isNextDay: false,
+        }));
+    return { ...item, operatingHours };
+  });
+
+  const result = await api.send('push-stores', { batchId, items });
+
+  return {
+    batchId,
+    itemCount: items.length,
+    reviewPath: `/review/${batchId}`,
+    ...(result as object),
+  };
+}

package/src/ws/ws-server.ts

@@ -0,0 +1,62 @@
+import { getAccessToken, refreshAccessToken, clearTokens } from '../auth.js';
+
+const DEFAULT_API_URL = 'http://localhost:8080';
+
+export class AdminApiClient {
+  private apiUrl: string;
+  private token: string | null = null;
+
+  constructor() {
+    this.apiUrl = process.env.ADMIN_API_URL || DEFAULT_API_URL;
+  }
+
+  async initialize(): Promise<void> {
+    this.token = await getAccessToken(this.apiUrl);
+  }
+
+  async send(method: string, params: unknown): Promise<unknown> {
+    if (!this.token) {
+      await this.initialize();
+    }
+
+    let response = await this.fetchApi(method, params);
+
+    // 401이면 토큰 refresh 시도
+    if (response.status === 401) {
+      const newToken = await refreshAccessToken(this.apiUrl);
+      if (newToken) {
+        this.token = newToken;
+        response = await this.fetchApi(method, params);
+      } else {
+        // refresh 실패 → 재로그인
+        await clearTokens();
+        this.token = await getAccessToken(this.apiUrl);
+        response = await this.fetchApi(method, params);
+      }
+    }
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`API 호출 실패 (${response.status}): ${text}`);
+    }
+
+    const json = await response.json();
+    return json.data ?? json;
+  }
+
+  private async fetchApi(method: string, params: unknown): Promise<Response> {
+    const url = `${this.apiUrl}/api/admin/mcp/${method}`;
+    return fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.token}`,
+      },
+      body: JSON.stringify(params),
+    });
+  }
+
+  isConnected(): boolean {
+    return this.token !== null;
+  }
+}