daiso 1.0.8 → 1.0.10

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 },
+            };
+        }),
+    };
+}

package/dist/services/feedback/types.js

@@ -0,0 +1,3 @@
+export const DEVELOPER_REQUEST_TYPES = ['bug', 'improvement', 'feature', 'docs', 'other'];
+export const DEVELOPER_REQUEST_SEVERITIES = ['low', 'medium', 'high', 'critical'];
+export const DEVELOPER_REQUEST_SOURCES = ['mcp', 'chatgpt', 'claude', 'cli', 'api', 'other'];

package/dist/services/gs25/client.js

@@ -6,6 +6,7 @@ import { fetchJson, fetchWithTimeout, HttpError } from '../../utils/http.js';
 import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
 import { GS25_API } from './api.js';
 import { normalizeStore, toNumber } from './storeUtils.js';
+export { fetchGs25NormalizedKeyword, fetchGs25SearchProducts, } from './productSearch.js';
 export { attachDistanceToGs25Stores, calculateDistanceM, extractGs25ProductCandidates, filterGs25StoresByKeyword, selectGs25StoresForKeyword, sortGs25Stores, } from './storeUtils.js';
 const GS25_DEFAULT_HEADERS = {
     Accept: 'application/json, text/plain, */*',
@@ -14,10 +15,6 @@ const GS25_DEFAULT_HEADERS = {
     Origin: 'https://woodongs.com',
     Referer: 'https://woodongs.com/',
 };
-const GS25_TOTAL_SEARCH_HEADERS = {
-    ...GS25_DEFAULT_HEADERS,
-    'Content-Type': 'application/json',
-};
 const GS25_DEFAULT_FETCH_OPTIONS = {
     retries: 1,
     retryDelayMs: 250,
@@ -91,40 +88,6 @@ async function fetchGs25StoreStock(url, options) {
         return decodeZyteHttpBody(result);
     }
 }
-async function fetchGs25TotalSearchResponse(query, options) {
-    const { timeout = 20000 } = options;
-    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
-    const bodyText = JSON.stringify({ query });
-    try {
-        return await fetchJson(endpoint.toString(), {
-            ...GS25_DEFAULT_FETCH_OPTIONS,
-            method: 'POST',
-            retryUnsafeMethods: true,
-            timeout,
-            headers: GS25_TOTAL_SEARCH_HEADERS,
-            body: bodyText,
-        });
-    }
-    catch (error) {
-        const zyteApiKey = options.zyteApiKey?.trim();
-        if (!(error instanceof HttpError) || error.status !== 403 || !zyteApiKey) {
-            throw error;
-        }
-        const result = await requestByZyte({
-            apiKey: zyteApiKey,
-            url: endpoint.toString(),
-            method: 'POST',
-            timeout,
-            retries: 1,
-            headers: Object.entries(GS25_TOTAL_SEARCH_HEADERS).map(([name, value]) => ({
-                name,
-                value,
-            })),
-            bodyText,
-        });
-        return decodeZyteHttpBody(result);
-    }
-}
 function buildCacheKey(params) {
     return [
         params.serviceCode,
@@ -332,52 +295,6 @@ export async function fetchGs25Stores(params = {}, options = {}) {
         cacheHit: false,
     };
 }
-export async function fetchGs25NormalizedKeyword(keyword, options = {}) {
-    const query = keyword.trim();
-    if (query.length === 0) {
-        return null;
-    }
-    const body = await fetchGs25TotalSearchResponse(query, options);
-    const normalizedKeyword = body.SearchQueryResult?.keywordInfo?.keyword?.trim() || '';
-    const normalizedSearchKeyword = body.SearchQueryResult?.keywordInfo?.searchKeyword?.trim() || '';
-    if (normalizedKeyword.length === 0 && normalizedSearchKeyword.length === 0) {
-        return null;
-    }
-    return {
-        keyword: normalizedKeyword,
-        searchKeyword: normalizedSearchKeyword,
-    };
-}
-/**
- * 키워드로 상품을 검색하여 itemCode 목록을 반환합니다.
- * 재고 조회 API는 itemCode가 필요하므로 이 함수로 먼저 변환해야 합니다.
- */
-export async function fetchGs25SearchProducts(keyword, options = {}) {
-    const query = keyword.trim();
-    if (query.length === 0) {
-        return [];
-    }
-    const body = await fetchGs25TotalSearchResponse(query, options);
-    const products = [];
-    const collections = body.SearchQueryResult?.Collection || [];
-    for (const collection of collections) {
-        const documents = collection.Documentset?.Document || [];
-        for (const doc of documents) {
-            const field = doc.field;
-            if (!field?.itemCode)
-                continue;
-            products.push({
-                itemCode: field.itemCode,
-                itemName: field.itemName || '',
-                shortItemName: field.shortItemName || '',
-                imageUrl: field.itemImageUrl || '',
-                rating: toNumber(field.starPoint),
-                stockCheckEnabled: field.stockCheckYn === 'Y',
-            });
-        }
-    }
-    return products;
-}
 export function clearGs25StoresCache() {
     gs25StoresCache.clear();
 }

package/dist/services/gs25/productSearch.js

@@ -0,0 +1,97 @@
+/**
+ * GS25 상품 검색 API
+ */
+/* c8 ignore start */
+import { fetchJson, HttpError } from '../../utils/http.js';
+import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
+import { GS25_API } from './api.js';
+import { toNumber } from './storeUtils.js';
+const GS25_TOTAL_SEARCH_HEADERS = {
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
+    'User-Agent': 'Mozilla/5.0 (Linux; Android 15; SM-S928N) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/124.0 Mobile Safari/537.36',
+    Origin: 'https://woodongs.com',
+    Referer: 'https://woodongs.com/',
+    'Content-Type': 'application/json',
+};
+const GS25_DEFAULT_FETCH_OPTIONS = {
+    retries: 1,
+    retryDelayMs: 250,
+};
+async function fetchGs25TotalSearchResponse(query, options) {
+    const { timeout = 20000 } = options;
+    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
+    const bodyText = JSON.stringify({ query });
+    try {
+        return await fetchJson(endpoint.toString(), {
+            ...GS25_DEFAULT_FETCH_OPTIONS,
+            method: 'POST',
+            retryUnsafeMethods: true,
+            timeout,
+            headers: GS25_TOTAL_SEARCH_HEADERS,
+            body: bodyText,
+        });
+    }
+    catch (error) {
+        const zyteApiKey = options.zyteApiKey?.trim();
+        if (!(error instanceof HttpError) || error.status !== 403 || !zyteApiKey) {
+            throw error;
+        }
+        const result = await requestByZyte({
+            apiKey: zyteApiKey,
+            url: endpoint.toString(),
+            method: 'POST',
+            timeout,
+            retries: 1,
+            headers: Object.entries(GS25_TOTAL_SEARCH_HEADERS).map(([name, value]) => ({
+                name,
+                value,
+            })),
+            bodyText,
+        });
+        return decodeZyteHttpBody(result);
+    }
+}
+export async function fetchGs25NormalizedKeyword(keyword, options = {}) {
+    const query = keyword.trim();
+    if (query.length === 0) {
+        return null;
+    }
+    const body = await fetchGs25TotalSearchResponse(query, options);
+    const normalizedKeyword = body.SearchQueryResult?.keywordInfo?.keyword?.trim() || '';
+    const normalizedSearchKeyword = body.SearchQueryResult?.keywordInfo?.searchKeyword?.trim() || '';
+    if (normalizedKeyword.length === 0 && normalizedSearchKeyword.length === 0) {
+        return null;
+    }
+    return {
+        keyword: normalizedKeyword,
+        searchKeyword: normalizedSearchKeyword,
+    };
+}
+export async function fetchGs25SearchProducts(keyword, options = {}) {
+    const query = keyword.trim();
+    if (query.length === 0) {
+        return [];
+    }
+    const body = await fetchGs25TotalSearchResponse(query, options);
+    const products = [];
+    const collections = body.SearchQueryResult?.Collection || [];
+    for (const collection of collections) {
+        const documents = collection.Documentset?.Document || [];
+        for (const doc of documents) {
+            const field = doc.field;
+            if (!field?.itemCode)
+                continue;
+            products.push({
+                itemCode: field.itemCode,
+                itemName: field.itemName || '',
+                shortItemName: field.shortItemName || '',
+                imageUrl: field.itemImageUrl || '',
+                rating: toNumber(field.starPoint),
+                stockCheckEnabled: field.stockCheckYn === 'Y',
+            });
+        }
+    }
+    return products;
+}
+/* c8 ignore stop */

package/dist/services/oliveyoung/client.js

@@ -4,68 +4,14 @@
  * Zyte extract API를 통해 올리브영 내부 API를 우회 호출합니다.
  */
 import { OLIVEYOUNG_API } from './api.js';
+import { resolveOliveyoungImageUrl, resolveOliveyoungInStock, resolveOliveyoungStoreStock, } from './normalize.js';
 import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
-const OLIVEYOUNG_IMAGE_HOST = 'https://image.oliveyoung.co.kr';
 const OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS = 10 * 60 * 1000;
 const OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS = 30 * 60 * 1000;
 const oliveyoungProductIdCache = new Map();
 const oliveyoungProductSearchCache = new Map();
 const oliveyoungStoreSearchCache = new Map();
 const oliveyoungStockStoresCache = new Map();
-const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
-function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
-    return o2oStockFlag || o2oRemainQuantity > 0;
-}
-function resolveOliveyoungImageUrl(imagePath) {
-    if (!imagePath) {
-        return undefined;
-    }
-    if (/^https?:\/\//i.test(imagePath)) {
-        return imagePath;
-    }
-    if (imagePath.startsWith('//')) {
-        return `https:${imagePath}`;
-    }
-    const normalizedPath = imagePath.startsWith('/') ? imagePath : `/${imagePath}`;
-    if (normalizedPath.startsWith(`${OLIVEYOUNG_IMAGE_PATH_PREFIX}/`)) {
-        return `${OLIVEYOUNG_IMAGE_HOST}${normalizedPath}`;
-    }
-    return `${OLIVEYOUNG_IMAGE_HOST}${OLIVEYOUNG_IMAGE_PATH_PREFIX}${normalizedPath}`;
-}
-function resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity) {
-    return Math.max(remainQuantity, o2oRemainQuantity);
-}
-function resolveOliveyoungStoreStock(rawStore) {
-    const remainQuantity = rawStore?.remainQuantity || 0;
-    const o2oRemainQuantity = rawStore?.o2oRemainQuantity || 0;
-    const quantity = resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity);
-    const salesStoreYn = Boolean(rawStore?.salesStoreYn);
-    let stockStatus = 'out_of_stock';
-    let stockLabel = '품절';
-    if (!salesStoreYn) {
-        stockStatus = 'not_sold';
-        stockLabel = '미판매';
-    }
-    else if (quantity > 0) {
-        stockStatus = 'in_stock';
-        stockLabel = quantity >= 9 ? '재고 9개 이상' : `재고 ${quantity}개`;
-    }
-    return {
-        storeCode: rawStore?.storeCode || '',
-        storeName: rawStore?.storeName || '',
-        address: rawStore?.address || '',
-        latitude: rawStore?.latitude || 0,
-        longitude: rawStore?.longitude || 0,
-        distance: rawStore?.distance || 0,
-        pickupYn: Boolean(rawStore?.pickupYn),
-        salesStoreYn,
-        remainQuantity,
-        o2oRemainQuantity,
-        stockStatus,
-        stockLabel,
-        openYn: Boolean(rawStore?.openYn),
-    };
-}
 function createOliveyoungProductSearchCacheKey(params) {
     return JSON.stringify([params.keyword, params.page, params.size, params.sort, params.includeSoldOut]);
 }

package/dist/services/oliveyoung/normalize.js

@@ -0,0 +1,58 @@
+/**
+ * 올리브영 응답 정규화 유틸리티
+ */
+const OLIVEYOUNG_IMAGE_HOST = 'https://image.oliveyoung.co.kr';
+const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
+export function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
+    return o2oStockFlag || o2oRemainQuantity > 0;
+}
+export function resolveOliveyoungImageUrl(imagePath) {
+    if (!imagePath) {
+        return undefined;
+    }
+    if (/^https?:\/\//i.test(imagePath)) {
+        return imagePath;
+    }
+    if (imagePath.startsWith('//')) {
+        return `https:${imagePath}`;
+    }
+    const normalizedPath = imagePath.startsWith('/') ? imagePath : `/${imagePath}`;
+    if (normalizedPath.startsWith(`${OLIVEYOUNG_IMAGE_PATH_PREFIX}/`)) {
+        return `${OLIVEYOUNG_IMAGE_HOST}${normalizedPath}`;
+    }
+    return `${OLIVEYOUNG_IMAGE_HOST}${OLIVEYOUNG_IMAGE_PATH_PREFIX}${normalizedPath}`;
+}
+function resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity) {
+    return Math.max(remainQuantity, o2oRemainQuantity);
+}
+export function resolveOliveyoungStoreStock(rawStore) {
+    const remainQuantity = rawStore?.remainQuantity || 0;
+    const o2oRemainQuantity = rawStore?.o2oRemainQuantity || 0;
+    const quantity = resolveOliveyoungStoreQuantity(remainQuantity, o2oRemainQuantity);
+    const salesStoreYn = Boolean(rawStore?.salesStoreYn);
+    let stockStatus = 'out_of_stock';
+    let stockLabel = '품절';
+    if (!salesStoreYn) {
+        stockStatus = 'not_sold';
+        stockLabel = '미판매';
+    }
+    else if (quantity > 0) {
+        stockStatus = 'in_stock';
+        stockLabel = quantity >= 9 ? '재고 9개 이상' : `재고 ${quantity}개`;
+    }
+    return {
+        storeCode: rawStore?.storeCode || '',
+        storeName: rawStore?.storeName || '',
+        address: rawStore?.address || '',
+        latitude: rawStore?.latitude || 0,
+        longitude: rawStore?.longitude || 0,
+        distance: rawStore?.distance || 0,
+        pickupYn: Boolean(rawStore?.pickupYn),
+        salesStoreYn,
+        remainQuantity,
+        o2oRemainQuantity,
+        stockStatus,
+        stockLabel,
+        openYn: Boolean(rawStore?.openYn),
+    };
+}