daiso 1.0.8 → 1.0.9

package/dist/index.js

@@ -20,7 +20,9 @@ import { createEmart24Service } from './services/emart24/index.js';
 import { createGs25Service } from './services/gs25/index.js';
 import { createSevenElevenService } from './services/seveneleven/index.js';
 import { createPlacesService } from './services/places/index.js';
+import { createOpinetService } from './services/opinet/index.js';
 import { createCompareService } from './services/compare/index.js';
+import { createFeedbackService } from './services/feedback/index.js';
 import { createPromptResponse } from './pages/prompt.js';
 import { createFullOpenApiJsonResponse, createFullOpenApiYamlResponse, createOpenApiJsonResponse, createOpenApiYamlResponse, } from './pages/openapi.js';
 import { createPrivacyResponse } from './pages/privacy.js';
@@ -36,7 +38,9 @@ import { registerEmart24Routes } from './api/routes/emart24Routes.js';
 import { registerGs25Routes } from './api/routes/gs25Routes.js';
 import { registerSevenElevenRoutes } from './api/routes/sevenelevenRoutes.js';
 import { registerPlacesRoutes } from './api/routes/placesRoutes.js';
+import { registerOpinetRoutes } from './api/routes/opinetRoutes.js';
 import { registerCompareRoutes } from './api/routes/compareRoutes.js';
+import { registerFeedbackRoutes } from './api/routes/feedbackRoutes.js';
 import { registerHealthRoutes } from './api/routes/healthRoutes.js';
 import { buildConfigStatus } from './api/configStatus.js';
 // 서버 메타데이터
@@ -58,10 +62,18 @@ const createRegistry = (bindings) => {
         }),
         createSevenElevenService,
         createCompareService,
+        () => createFeedbackService({
+            supabaseUrl: bindings?.SUPABASE_URL,
+            supabaseServiceRoleKey: bindings?.SUPABASE_SERVICE_ROLE_KEY,
+        }),
         () => createPlacesService({
             naverClientId: bindings?.NAVER_CLIENT_ID,
             naverClientSecret: bindings?.NAVER_CLIENT_SECRET,
         }),
+        () => createOpinetService({
+            apiKey: bindings?.OPINET_API_KEY,
+            googleMapsApiKey: bindings?.GOOGLE_MAPS_API_KEY,
+        }),
         createCuService,
         createEmart24Service,
         () => createLotteMartService({
@@ -94,6 +106,53 @@ const createMcpServer = (bindings) => {
     registry.applyToServer(server);
     return server;
 };
+function buildRootInfo() {
+    const registry = createRegistry();
+    const services = registry.getServicesInfo();
+    const allTools = registry.getAllToolNames();
+    return {
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+        description: 'Multi-Service MCP Server for Cloudflare Workers',
+        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',
+            compareProducts: '/api/compare/products (GET) - 키 없는 통합 상품 가격 후보 비교',
+            opinetAverage: '/api/opinet/average (GET) - 오피넷 전국 평균 유가',
+            opinetLowest: '/api/opinet/lowest (GET) - 오피넷 최저가 주유소',
+            developerRequests: '/api/feedback/requests (POST/GET) - 개발자 요청 제출',
+        },
+        services,
+        tools: allTools,
+        totalServices: services.length,
+        totalTools: allTools.length,
+    };
+}
+const ROOT_INFO_JSON = JSON.stringify(buildRootInfo());
+const ROOT_INFO_BODY = new TextEncoder().encode(ROOT_INFO_JSON);
+const ROOT_INFO_HEADERS = {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': String(ROOT_INFO_BODY.byteLength),
+    'Access-Control-Allow-Origin': '*',
+    'Cache-Control': 'public, max-age=300, s-maxage=3600, stale-while-revalidate=86400',
+};
+function isRootInfoRequest(request) {
+    if (request.method !== 'GET' && request.method !== 'HEAD') {
+        return false;
+    }
+    const url = new URL(request.url);
+    return url.pathname === '/' && url.search === '';
+}
+function createRootInfoResponse(method) {
+    return new Response(method === 'HEAD' ? null : ROOT_INFO_BODY, {
+        status: 200,
+        headers: ROOT_INFO_HEADERS,
+    });
+}
 /**
  * initialize 요청 여부를 확인합니다.
  */
@@ -166,6 +225,24 @@ const handleMcpRequest = async (c) => {
         message: `세션이 없습니다. 먼저 POST /mcp initialize 요청 후 ${SESSION_HEADER} 헤더를 사용해주세요.`,
     }, 400);
 };
+const handleRootMcpRequest = async (c) => {
+    if (c.req.header(SESSION_HEADER) || c.req.method === 'DELETE') {
+        return handleMcpRequest(c);
+    }
+    const parsedBody = await c.req.raw
+        .clone()
+        .json()
+        .catch(() => undefined);
+    if (isInitializeRequest(parsedBody)) {
+        const { server, transport } = createSessionTransport(c.env);
+        await server.connect(transport);
+        return transport.handleRequest(c.req.raw, { parsedBody });
+    }
+    const transport = new WebStandardStreamableHTTPServerTransport();
+    const server = createMcpServer(c.env);
+    await server.connect(transport);
+    return transport.handleRequest(c.req.raw, { parsedBody });
+};
 // Hono 앱 생성
 const app = new Hono();
 // CORS 설정
@@ -184,35 +261,10 @@ app.use('*', cors({
 }));
 // 기본 정보 엔드포인트 (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) - 헬스 체크',
-            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',
-            compareProducts: '/api/compare/products (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);
+    return c.body(ROOT_INFO_JSON, 200, ROOT_INFO_HEADERS);
 });
+// 루트 경로에서 MCP 요청 처리 (POST, DELETE)
+app.on(['POST', 'DELETE'], '/', handleRootMcpRequest);
 // 헬스 체크 엔드포인트
 app.get('/health', (c) => c.json({ status: 'ok', config: buildConfigStatus(c.env) }));
 registerHealthRoutes(app);
@@ -248,7 +300,9 @@ registerDaisoRoutes(app);
 registerGs25Routes(app);
 registerSevenElevenRoutes(app);
 registerCompareRoutes(app);
+registerFeedbackRoutes(app);
 registerPlacesRoutes(app);
+registerOpinetRoutes(app);
 registerCuRoutes(app);
 registerEmart24Routes(app);
 registerLotteMartRoutes(app);
@@ -279,4 +333,13 @@ app.get('/api/actions/query', async (c) => {
 });
 // MCP 엔드포인트
 app.all('/mcp', handleMcpRequest);
-export default app;
+const worker = {
+    fetch(request, env, executionCtx) {
+        if (isRootInfoRequest(request)) {
+            return createRootInfoResponse(request.method);
+        }
+        return app.fetch(request, env, executionCtx);
+    },
+    request: app.request.bind(app),
+};
+export default worker;

package/dist/pages/openapiFullSpec.js

@@ -11,7 +11,9 @@ import { OPENAPI_PATHS_LOTTECINEMA } from './openapiSpecPathsLottecinema.js';
 import { OPENAPI_PATHS_GS25 } from './openapiSpecPathsGs25.js';
 import { OPENAPI_PATHS_SEVENELEVEN } from './openapiSpecPathsSeveneleven.js';
 import { OPENAPI_PATHS_PLACES } from './openapiSpecPathsPlaces.js';
+import { OPENAPI_PATHS_OPINET } from './openapiSpecPathsOpinet.js';
 import { OPENAPI_PATHS_COMPARE } from './openapiSpecPathsCompare.js';
+import { OPENAPI_PATHS_FEEDBACK } from './openapiSpecPathsFeedback.js';
 import { OPENAPI_COMPONENTS } from './openapiSpecComponents.js';
 export function generateFullOpenApiSpec(baseUrl) {
     return {
@@ -33,6 +35,7 @@ export function generateFullOpenApiSpec(baseUrl) {
 - 🎞️ **롯데시네마 지점/영화 조회**: 주변 지점, 상영 목록, 잔여 좌석 조회
 - 🎥 **CGV 지점/영화 조회**: 극장 목록, 영화 목록, 시간표 조회
 - 🍽️ **주변 음식점/카페 검색**: 네이버 지역 검색 기반 장소 조회
+- ⛽ **오피넷 유가 정보**: 전국 평균 유가, 최저가 주유소, 반경 내 주유소 조회
 
 ## 사용 팁
 1. 한글 검색어는 URL 인코딩이 자동 처리됩니다
@@ -54,7 +57,9 @@ export function generateFullOpenApiSpec(baseUrl) {
             ...OPENAPI_PATHS_GS25,
             ...OPENAPI_PATHS_SEVENELEVEN,
             ...OPENAPI_PATHS_COMPARE,
+            ...OPENAPI_PATHS_FEEDBACK,
             ...OPENAPI_PATHS_PLACES,
+            ...OPENAPI_PATHS_OPINET,
             ...OPENAPI_PATHS_MEGABOX,
             ...OPENAPI_PATHS_LOTTECINEMA,
             ...OPENAPI_PATHS_CGV,

package/dist/pages/openapiSpecActions.js

@@ -70,6 +70,69 @@ const ACTION_QUERY_PARAMETERS = [
         description: '통합 비교 서비스 목록(daiso,gs25,seveneleven,emart24)',
         schema: { type: 'string' },
     },
+    {
+        name: 'type',
+        in: 'query',
+        required: false,
+        description: '개발자 요청 유형(bug, improvement, feature, docs, other)',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'severity',
+        in: 'query',
+        required: false,
+        description: '개발자 요청 영향도(low, medium, high, critical)',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'title',
+        in: 'query',
+        required: false,
+        description: '개발자 요청 제목',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'description',
+        in: 'query',
+        required: false,
+        description: '개발자 요청 상세 설명',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'toolName',
+        in: 'query',
+        required: false,
+        description: '문제가 발생했거나 개선이 필요한 MCP 도구 이름',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'reproduction',
+        in: 'query',
+        required: false,
+        description: '오류 재현 방법',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'expected',
+        in: 'query',
+        required: false,
+        description: '기대 결과',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'actual',
+        in: 'query',
+        required: false,
+        description: '실제 결과',
+        schema: { type: 'string' },
+    },
+    {
+        name: 'source',
+        in: 'query',
+        required: false,
+        description: '요청 출처(mcp, chatgpt, claude, cli, api, other)',
+        schema: { type: 'string' },
+    },
     {
         name: 'sido',
         in: 'query',

package/dist/pages/openapiSpecPathsFeedback.js

@@ -0,0 +1,95 @@
+const REQUEST_PROPERTIES = {
+    type: {
+        type: 'string',
+        enum: ['bug', 'improvement', 'feature', 'docs', 'other'],
+        default: 'other',
+    },
+    severity: {
+        type: 'string',
+        enum: ['low', 'medium', 'high', 'critical'],
+        default: 'medium',
+    },
+    title: { type: 'string' },
+    description: { type: 'string' },
+    service: { type: 'string' },
+    toolName: { type: 'string' },
+    reproduction: { type: 'string' },
+    expected: { type: 'string' },
+    actual: { type: 'string' },
+    source: {
+        type: 'string',
+        enum: ['mcp', 'chatgpt', 'claude', 'cli', 'api', 'other'],
+    },
+};
+const RESPONSE_SCHEMA = {
+    type: 'object',
+    properties: {
+        success: { type: 'boolean' },
+        data: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                type: { type: 'string' },
+                severity: { type: 'string' },
+                title: { type: 'string' },
+                service: { type: 'string' },
+                toolName: { type: 'string' },
+                source: { type: 'string' },
+                status: { type: 'string' },
+                createdAt: { type: 'string' },
+            },
+        },
+    },
+};
+export const OPENAPI_PATHS_FEEDBACK = {
+    '/api/feedback/requests': {
+        post: {
+            operationId: 'submitDeveloperRequest',
+            summary: '개발자 요청 제출',
+            description: 'MCP 기능 오류, 개선 요청, 신규 기능 요청, 문서 문제를 개발자에게 전달하고 Supabase에 저장합니다.',
+            requestBody: {
+                required: true,
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'object',
+                            required: ['title', 'description'],
+                            properties: REQUEST_PROPERTIES,
+                        },
+                    },
+                },
+            },
+            responses: {
+                '200': {
+                    description: '개발자 요청 저장 결과',
+                    content: {
+                        'application/json': {
+                            schema: RESPONSE_SCHEMA,
+                        },
+                    },
+                },
+            },
+        },
+        get: {
+            operationId: 'submitDeveloperRequestViaQuery',
+            summary: '개발자 요청 제출(GET)',
+            description: 'OpenAI Actions facade 등 GET만 가능한 환경에서 개발자 요청을 제출합니다.',
+            parameters: Object.entries(REQUEST_PROPERTIES).map(([name, schema]) => ({
+                name,
+                in: 'query',
+                required: name === 'title' || name === 'description',
+                schema,
+            })),
+            responses: {
+                '200': {
+                    description: '개발자 요청 저장 결과',
+                    content: {
+                        'application/json': {
+                            schema: RESPONSE_SCHEMA,
+                        },
+                    },
+                },
+            },
+        },
+    },
+};

package/dist/pages/openapiSpecPathsOpinet.js

@@ -0,0 +1,81 @@
+/**
+ * OpenAPI 경로 정의 (오피넷)
+ */
+const fuelCodeSchema = {
+    type: 'string',
+    enum: ['B027', 'D047', 'B034', 'C004', 'K015'],
+    default: 'B027',
+};
+const successResponse = {
+    description: '조회 성공',
+    content: {
+        'application/json': {
+            schema: {
+                type: 'object',
+                properties: {
+                    success: { type: 'boolean' },
+                    data: { type: 'object' },
+                },
+            },
+        },
+    },
+};
+export const OPENAPI_PATHS_OPINET = {
+    '/api/opinet/average': {
+        get: {
+            operationId: 'opinetGetAveragePrices',
+            summary: '오피넷 전국 평균 유가',
+            description: '한국석유공사 오피넷 전국 평균 유가를 조회합니다.',
+            parameters: [],
+            responses: {
+                '200': successResponse,
+                '500': {
+                    description: '오피넷 키 누락 또는 API 호출 실패',
+                    content: { 'application/json': { schema: { $ref: '#/components/schemas/ErrorResponse' } } },
+                },
+            },
+        },
+    },
+    '/api/opinet/lowest': {
+        get: {
+            operationId: 'opinetGetLowestPriceStations',
+            summary: '오피넷 최저가 주유소',
+            description: '전국 또는 지역별 최저가 주유소를 유종별로 조회합니다.',
+            parameters: [
+                { name: 'fuelCode', in: 'query', required: false, description: '유종 코드', schema: fuelCodeSchema },
+                { name: 'areaCode', in: 'query', required: false, description: '오피넷 지역 코드', schema: { type: 'string' } },
+                { name: 'count', in: 'query', required: false, description: '결과 수(1~20)', schema: { type: 'integer', minimum: 1, maximum: 20, default: 10 } },
+            ],
+            responses: { '200': successResponse },
+        },
+    },
+    '/api/opinet/stations/around': {
+        get: {
+            operationId: 'opinetSearchStationsAround',
+            summary: '오피넷 반경 내 주유소',
+            description: 'KATEC x/y, WGS84 위경도, 또는 location 키워드 기준 반경 내 주유소를 조회합니다.',
+            parameters: [
+                { name: 'x', in: 'query', required: false, description: '기준 위치 X좌표(KATEC)', schema: { type: 'number' } },
+                { name: 'y', in: 'query', required: false, description: '기준 위치 Y좌표(KATEC)', schema: { type: 'number' } },
+                { name: 'lat', in: 'query', required: false, description: '위도(WGS84)', schema: { type: 'number' } },
+                { name: 'lng', in: 'query', required: false, description: '경도(WGS84)', schema: { type: 'number' } },
+                { name: 'location', in: 'query', required: false, description: '장소/주소 키워드. 예: 강남역', schema: { type: 'string' } },
+                { name: 'radiusMeters', in: 'query', required: false, description: '검색 반경 m(100~5000)', schema: { type: 'integer', minimum: 100, maximum: 5000, default: 3000 } },
+                { name: 'fuelCode', in: 'query', required: false, description: '유종 코드', schema: fuelCodeSchema },
+                { name: 'sort', in: 'query', required: false, description: '정렬 기준', schema: { type: 'string', enum: ['price', 'distance'], default: 'price' } },
+            ],
+            responses: { '200': successResponse },
+        },
+    },
+    '/api/opinet/station': {
+        get: {
+            operationId: 'opinetGetStationDetail',
+            summary: '오피넷 주유소 상세정보',
+            description: '오피넷 주유소 ID로 상세 정보, 부가시설, 유종별 가격을 조회합니다.',
+            parameters: [
+                { name: 'id', in: 'query', required: true, description: '오피넷 주유소 ID', schema: { type: 'string' } },
+            ],
+            responses: { '200': successResponse },
+        },
+    },
+};

package/dist/pages/promptReferenceText.js

@@ -58,6 +58,20 @@ export function buildPromptReferenceText(baseUrl) {
 | LOTTEMART_PRODUCT_SEARCH_FAILED | 롯데마트 상품 조회 실패 |
 | SEVENELEVEN_INVENTORY_CHECK_FAILED | 세븐일레븐 재고 조회 실패 |
 | PLACES_SEARCH_FAILED | 주변 장소 검색 실패 |
+| DEVELOPER_REQUEST_SUBMIT_FAILED | 개발자 요청 저장 실패 |
+
+---
+
+## 에이전트 실행 레시피
+
+- "콜라 어디가 싸?", "컵라면 가격 비교해줘": 먼저 \`compare_products\` 또는 /api/compare/products를 호출합니다. 실제 재고와 매장 행사가가 필요하면 최저가 후보의 서비스별 재고/상품 도구로 한 번 더 확인합니다.
+- "강남역 근처 카페", "성수동 브런치 음식점": 브랜드를 되묻지 말고 \`places_search_nearby\` 또는 /api/places/search를 호출합니다. 이 검색은 키워드 기반이므로 좌표 반경 결과처럼 단정하지 않습니다.
+- "다이소 핫식스 재고", "올리브영 두바이초콜릿 있어?": 상품이 브랜드와 어색해 보여도 브랜드를 바꾸지 말고 먼저 다이소로 검색하거나 명시된 서비스로 검색합니다. 결과가 없을 때만 다른 서비스 대안을 제안합니다.
+- "GS25 강남 오감자 재고": 상품명과 위치를 분리해 상품 후보를 먼저 찾고, 선택한 itemCode나 keyword와 storeKeyword로 재고를 확인합니다.
+- "오늘 강남 CGV 시간표": 오늘 날짜는 KST 기준 YYYYMMDD로 계산하고, theaterCode가 없으면 극장 검색 후 시간표를 조회합니다.
+- MCP 기능이 제대로 동작하지 않거나 개선/신규 기능 요청이 있으면 \`submit_developer_request\` 또는 /api/feedback/requests를 사용해 개발자에게 전달합니다. 제목과 설명은 필수입니다.
+- 도구 호출이 실패하면 같은 도구를 한 번 더 좁은 조건으로 재시도합니다. 두 번 실패하면 실패한 서비스와 요청 조건을 밝히고 추측으로 결과를 만들지 않습니다.
+- 결과에 imageUrl이 있으면 각 항목 이미지 표시를 우선합니다. 쿼리 문자열이 있는 이미지 URL도 그대로 사용합니다.
 
 ---
 
@@ -125,6 +139,7 @@ MCP 연결 정보: ${baseUrl}/mcp
 - seveneleven_get_search_popwords: 세븐일레븐 인기 검색어 조회
 - seveneleven_get_catalog_snapshot: 세븐일레븐 카탈로그 조회
 - compare_products: 키 없는 통합 상품 가격 후보 비교
+- submit_developer_request: MCP 오류, 개선 요청, 신규 기능 요청을 개발자에게 전달
 - places_search_nearby: 음식점/카페 등 주변 장소 검색
 - oliveyoung_search_products: 올리브영 상품 검색
 - oliveyoung_find_nearby_stores: 올리브영 주변 매장 탐색

package/dist/services/feedback/client.js

@@ -0,0 +1,109 @@
+import { DEVELOPER_REQUEST_SEVERITIES, DEVELOPER_REQUEST_SOURCES, DEVELOPER_REQUEST_TYPES, } from './types.js';
+function isOneOf(value, allowed) {
+    return Boolean(value && allowed.includes(value));
+}
+function trimText(value, maxLength) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.length > maxLength ? trimmed.slice(0, maxLength) : trimmed;
+}
+function requireText(value, fieldName, maxLength) {
+    const text = trimText(value, maxLength);
+    if (!text) {
+        throw new Error(`${fieldName}를 입력해주세요.`);
+    }
+    return text;
+}
+function normalizeType(value) {
+    return isOneOf(value, DEVELOPER_REQUEST_TYPES) ? value : 'other';
+}
+function normalizeSeverity(value) {
+    return isOneOf(value, DEVELOPER_REQUEST_SEVERITIES) ? value : 'medium';
+}
+function normalizeSource(value) {
+    return isOneOf(value, DEVELOPER_REQUEST_SOURCES) ? value : undefined;
+}
+function createInsertRow(input) {
+    const row = {
+        type: normalizeType(trimText(input.type, 40)),
+        severity: normalizeSeverity(trimText(input.severity, 40)),
+        title: requireText(input.title, 'title', 160),
+        description: requireText(input.description, 'description', 4000),
+        status: 'open',
+    };
+    const service = trimText(input.service, 80);
+    const toolName = trimText(input.toolName, 120);
+    const reproduction = trimText(input.reproduction, 4000);
+    const expected = trimText(input.expected, 2000);
+    const actual = trimText(input.actual, 2000);
+    const source = normalizeSource(trimText(input.source, 40));
+    if (service)
+        row.service = service;
+    if (toolName)
+        row.tool_name = toolName;
+    if (reproduction)
+        row.reproduction = reproduction;
+    if (expected)
+        row.expected = expected;
+    if (actual)
+        row.actual = actual;
+    if (source)
+        row.source = source;
+    if (input.userContext && typeof input.userContext === 'object') {
+        row.user_context = input.userContext;
+    }
+    return row;
+}
+function requireConfig(config) {
+    const supabaseUrl = trimText(config.supabaseUrl, 400);
+    const key = trimText(config.supabaseServiceRoleKey, 4000);
+    if (!supabaseUrl || !key) {
+        throw new Error('SUPABASE_URL과 SUPABASE_SERVICE_ROLE_KEY가 필요합니다.');
+    }
+    return { supabaseUrl: supabaseUrl.replace(/\/+$/, ''), key };
+}
+function stringOrUndefined(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function resultFromRow(row, fallback) {
+    return {
+        id: stringOrUndefined(row.id) || '',
+        type: normalizeType(stringOrUndefined(row.type) || fallback.type),
+        severity: normalizeSeverity(stringOrUndefined(row.severity) || fallback.severity),
+        title: stringOrUndefined(row.title) || fallback.title,
+        service: stringOrUndefined(row.service) || fallback.service,
+        toolName: stringOrUndefined(row.tool_name) || fallback.tool_name,
+        source: normalizeSource(stringOrUndefined(row.source)) || fallback.source,
+        status: stringOrUndefined(row.status) || fallback.status,
+        createdAt: stringOrUndefined(row.created_at),
+    };
+}
+export async function submitDeveloperRequest(input, config) {
+    const { supabaseUrl, key } = requireConfig(config);
+    const row = createInsertRow(input);
+    const response = await fetch(`${supabaseUrl}/rest/v1/agent_requests`, {
+        method: 'POST',
+        headers: {
+            apikey: key,
+            Authorization: `Bearer ${key}`,
+            'Content-Type': 'application/json',
+            Prefer: 'return=representation',
+        },
+        body: JSON.stringify(row),
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => '');
+        throw new Error(`Supabase 저장 실패: ${response.status}${detail ? ` ${detail}` : ''}`);
+    }
+    const payload = (await response.json());
+    const returnedRow = Array.isArray(payload) ? payload[0] : payload;
+    if (!returnedRow || typeof returnedRow !== 'object') {
+        throw new Error('Supabase 저장 결과가 비어 있습니다.');
+    }
+    return resultFromRow(returnedRow, row);
+}

package/dist/services/feedback/index.js

@@ -0,0 +1,22 @@
+import { createSubmitDeveloperRequestTool } from './tools/submitDeveloperRequest.js';
+const FEEDBACK_METADATA = {
+    id: 'feedback',
+    name: '개발자 요청',
+    version: '1.0.0',
+    description: 'AI 에이전트가 MCP 오류, 개선 요청, 신규 기능 요청을 개발자에게 전달하는 서비스',
+};
+class FeedbackService {
+    config;
+    metadata = FEEDBACK_METADATA;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    getTools() {
+        return [createSubmitDeveloperRequestTool(this.config)];
+    }
+}
+export function createFeedbackService(config = {}) {
+    return new FeedbackService(config);
+}
+export * from './client.js';
+export * from './types.js';

package/dist/services/feedback/tools/submitDeveloperRequest.js

@@ -0,0 +1,54 @@
+import * as z from 'zod';
+import { submitDeveloperRequest } from '../client.js';
+export function createSubmitDeveloperRequestTool(config) {
+    return {
+        name: 'submit_developer_request',
+        metadata: {
+            title: '개발자 요청 제출',
+            description: 'MCP 기능 오류, 개선 요청, 신규 기능 요청, 문서 문제를 개발자에게 전달하고 Supabase에 저장합니다.',
+            inputSchema: {
+                type: z
+                    .enum(['bug', 'improvement', 'feature', 'docs', 'other'])
+                    .optional()
+                    .default('other')
+                    .describe('요청 유형'),
+                severity: z
+                    .enum(['low', 'medium', 'high', 'critical'])
+                    .optional()
+                    .default('medium')
+                    .describe('영향도'),
+                title: z.string().describe('짧은 제목'),
+                description: z.string().describe('요청 상세 설명'),
+                service: z.string().optional().describe('관련 서비스 ID 또는 영역'),
+                toolName: z.string().optional().describe('관련 MCP 도구 이름'),
+                reproduction: z.string().optional().describe('재현 방법'),
+                expected: z.string().optional().describe('기대 결과'),
+                actual: z.string().optional().describe('실제 결과'),
+                source: z
+                    .enum(['mcp', 'chatgpt', 'claude', 'cli', 'api', 'other'])
+                    .optional()
+                    .default('mcp')
+                    .describe('요청 출처'),
+                userContext: z.object({}).loose().optional().describe('추가 컨텍스트 JSON'),
+            },
+            outputSchema: {
+                id: z.string().optional(),
+                type: z.string().optional(),
+                severity: z.string().optional(),
+                title: z.string().optional(),
+                service: z.string().optional(),
+                toolName: z.string().optional(),
+                source: z.string().optional(),
+                status: z.string().optional(),
+                createdAt: z.string().optional(),
+            },
+        },
+        handler: (async (args) => {
+            const result = await submitDeveloperRequest(args, config);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                structuredContent: { ...result },
+            };
+        }),
+    };
+}