daiso 1.0.4 → 1.0.6

package/dist/services/cgv/tools/findTheaters.js

@@ -3,8 +3,27 @@
  */
 import * as z from 'zod';
 import { fetchCgvTheaters, toYyyymmdd } from '../client.js';
-async function findTheaters(args, apiKey) {
-    const { playDate = toYyyymmdd(), regionCode, limit = 30, timeoutMs = 15000 } = args;
+import { fetchCgvNearbyTheaters } from '../location.js';
+async function findTheaters(args, apiKey, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), regionCode, keyword, latitude, longitude, limit = 30, timeoutMs = 15000, } = args;
+    if (keyword || typeof latitude === 'number' || typeof longitude === 'number') {
+        const result = await fetchCgvNearbyTheaters({
+            playDate,
+            regionCode,
+            keyword,
+            latitude,
+            longitude,
+            limit,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    }
     const theaters = await fetchCgvTheaters({
         playDate,
         regionCode,
@@ -16,6 +35,9 @@ async function findTheaters(args, apiKey) {
         playDate,
         filters: {
             regionCode: regionCode || null,
+            keyword: keyword || null,
+            latitude: latitude ?? null,
+            longitude: longitude ?? null,
             limit,
         },
         count: sliced.length,
@@ -25,19 +47,22 @@ async function findTheaters(args, apiKey) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createFindTheatersTool(apiKey) {
+export function createFindTheatersTool(apiKey, googleMapsApiKey) {
     return {
         name: 'cgv_find_theaters',
         metadata: {
             title: 'CGV 극장 검색',
-            description: '지역 코드 기준으로 CGV 극장 목록을 조회합니다.',
+            description: '지역 코드 또는 위치 키워드 기준으로 CGV 극장 목록을 조회합니다.',
             inputSchema: {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 regionCode: z.string().optional().describe('지역 코드 (예: 01 서울)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 limit: z.number().optional().default(30).describe('최대 결과 수 (기본값: 30)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => findTheaters(args, apiKey)),
+        handler: ((args) => findTheaters(args, apiKey, googleMapsApiKey)),
     };
 }

package/dist/services/cgv/tools/getTimetable.js

@@ -3,24 +3,49 @@
  */
 import * as z from 'zod';
 import { fetchCgvTimetable, toYyyymmdd } from '../client.js';
+import { resolveCgvNearestTheater } from '../location.js';
 import { filterAndSortTimetable } from '../timetable.js';
-async function getTimetable(args, apiKey) {
-    const { playDate = toYyyymmdd(), theaterCode, movieCode, limit = 50, timeoutMs = 15000, } = args;
-    const timetable = await fetchCgvTimetable({
-        playDate,
-        theaterCode,
-        movieCode,
-        timeout: timeoutMs,
-        zyteApiKey: apiKey,
-    });
-    const filtered = filterAndSortTimetable(timetable, { theaterCode, movieCode, limit });
+async function getTimetable(args, apiKey, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterCode, movieCode, keyword, latitude, longitude, limit = 50, timeoutMs = 15000, } = args;
+    let resolvedTheater = null;
+    let targetTheaterCode = theaterCode;
+    if (!targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveCgvNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterCode = resolved.theater?.theaterCode;
+    }
+    const shouldReturnEmpty = !targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const timetable = shouldReturnEmpty
+        ? []
+        : await fetchCgvTimetable({
+            playDate,
+            theaterCode: targetTheaterCode,
+            movieCode,
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+        });
+    const filtered = filterAndSortTimetable(timetable, { theaterCode: targetTheaterCode, movieCode, limit });
     const result = {
         playDate,
         filters: {
-            theaterCode: theaterCode || null,
+            theaterCode: targetTheaterCode || null,
             movieCode: movieCode || null,
+            keyword: keyword || null,
+            latitude: latitude ?? null,
+            longitude: longitude ?? null,
             limit,
         },
+        resolvedTheater,
         count: filtered.length,
         timetable: filtered,
     };
@@ -28,20 +53,23 @@ async function getTimetable(args, apiKey) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createGetTimetableTool(apiKey) {
+export function createGetTimetableTool(apiKey, googleMapsApiKey) {
     return {
         name: 'cgv_get_timetable',
         metadata: {
             title: 'CGV 시간표 조회',
-            description: '날짜/극장/영화 조건으로 CGV 상영 시간표를 조회합니다.',
+            description: '날짜/극장/영화 조건으로 CGV 상영 시간표를 조회합니다. 극장 코드가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
             inputSchema: {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterCode: z.string().optional().describe('CGV 극장 코드 (예: 0056)'),
                 movieCode: z.string().optional().describe('CGV 영화 코드'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 limit: z.number().optional().default(50).describe('최대 결과 수 (기본값: 50)'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => getTimetable(args, apiKey)),
+        handler: ((args) => getTimetable(args, apiKey, googleMapsApiKey)),
     };
 }

package/dist/services/cgv/tools/searchMovies.js

@@ -3,19 +3,44 @@
  */
 import * as z from 'zod';
 import { fetchCgvMovies, toYyyymmdd } from '../client.js';
-async function searchMovies(args, apiKey) {
-    const { playDate = toYyyymmdd(), theaterCode, timeoutMs = 15000 } = args;
-    const movies = await fetchCgvMovies({
-        playDate,
-        theaterCode,
-        timeout: timeoutMs,
-        zyteApiKey: apiKey,
-    });
+import { resolveCgvNearestTheater } from '../location.js';
+async function searchMovies(args, apiKey, googleMapsApiKey) {
+    const { playDate = toYyyymmdd(), theaterCode, keyword, latitude, longitude, timeoutMs = 15000 } = args;
+    let resolvedTheater = null;
+    let targetTheaterCode = theaterCode;
+    if (!targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number')) {
+        const resolved = await resolveCgvNearestTheater({
+            playDate,
+            keyword,
+            latitude,
+            longitude,
+            timeout: timeoutMs,
+        }, {
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+            googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
+        });
+        resolvedTheater = resolved.theater;
+        targetTheaterCode = resolved.theater?.theaterCode;
+    }
+    const shouldReturnEmpty = !targetTheaterCode && (keyword || typeof latitude === 'number' || typeof longitude === 'number');
+    const movies = shouldReturnEmpty
+        ? []
+        : await fetchCgvMovies({
+            playDate,
+            theaterCode: targetTheaterCode,
+            timeout: timeoutMs,
+            zyteApiKey: apiKey,
+        });
     const result = {
         playDate,
         filters: {
-            theaterCode: theaterCode || null,
+            theaterCode: targetTheaterCode || null,
+            keyword: keyword || null,
+            latitude: latitude ?? null,
+            longitude: longitude ?? null,
         },
+        resolvedTheater,
         count: movies.length,
         movies,
     };
@@ -23,18 +48,21 @@ async function searchMovies(args, apiKey) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createSearchMoviesTool(apiKey) {
+export function createSearchMoviesTool(apiKey, googleMapsApiKey) {
     return {
         name: 'cgv_search_movies',
         metadata: {
             title: 'CGV 영화 검색',
-            description: 'CGV 상영 영화 목록을 조회합니다.',
+            description: 'CGV 상영 영화 목록을 조회합니다. 극장 코드가 없으면 위치 키워드 기준 최근접 극장을 선택할 수 있습니다.',
             inputSchema: {
                 playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
                 theaterCode: z.string().optional().describe('CGV 극장 코드 (예: 0056)'),
+                keyword: z.string().optional().describe('위치 키워드 (예: 안산 중앙역, 강남역)'),
+                latitude: z.number().optional().describe('위도'),
+                longitude: z.number().optional().describe('경도'),
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: ((args) => searchMovies(args, apiKey)),
+        handler: ((args) => searchMovies(args, apiKey, googleMapsApiKey)),
     };
 }

package/dist/services/cgv/transport.js

@@ -7,11 +7,9 @@ import { createTimeoutController } from '../../utils/http.js';
 import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
 import { CGV_API } from './api.js';
 function toBase64(bytes) {
-    /* c8 ignore start */
     if (typeof Buffer !== 'undefined') {
         return Buffer.from(bytes).toString('base64');
     }
-    /* c8 ignore end */
     let binary = '';
     for (const byte of bytes) {
         binary += String.fromCharCode(byte);
@@ -19,7 +17,6 @@ function toBase64(bytes) {
     if (typeof btoa === 'function') {
         return btoa(binary);
     }
-    /* c8 ignore next */
     throw new Error('Base64 인코딩을 지원하지 않는 런타임입니다.');
 }
 async function createSignature(pathname, bodyText, timestamp) {

package/dist/services/cu/api.js

@@ -0,0 +1,11 @@
+/**
+ * CU API 엔드포인트 중앙 관리
+ */
+export const CU_API = {
+    BASE_URL: 'https://www.pocketcu.co.kr',
+    STORE_PATH: '/api/store',
+    STOCK_DISPLAY_PATH: '/api/search/display/stock',
+    STOCK_MAIN_PATH: '/api/search/rest/stock/main',
+    WEB_BASE_URL: 'https://cu.bgfretail.com',
+    WEB_STORE_LIST_PATH: '/store/list_Ajax.do',
+};

package/dist/services/cu/client.js

@@ -0,0 +1,297 @@
+/**
+ * CU API 클라이언트
+ */
+import { fetchJson } from '../../utils/http.js';
+import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { CU_API } from './api.js';
+const CU_DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json, text/javascript, */*; q=0.01',
+    'X-Requested-With': 'XMLHttpRequest',
+};
+const CU_WEB_DEFAULT_HEADERS = {
+    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+    'X-Requested-With': 'XMLHttpRequest',
+    Accept: 'text/html, */*; q=0.01',
+    'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
+    Origin: 'https://cu.bgfretail.com',
+    Referer: 'https://cu.bgfretail.com/store/list.do?category=store',
+};
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toYnBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toUpperCase();
+        return normalized === 'Y' || normalized === 'TRUE';
+    }
+    return false;
+}
+function toStoreAddress(raw) {
+    const road = [raw.doroStoreAddr1 || '', raw.doroStoreAddr2 || ''].join(' ').trim();
+    if (road.length > 0) {
+        return road;
+    }
+    return [raw.addrFst || '', raw.addrDetail || ''].join(' ').trim();
+}
+async function requestCuJson(path, body, timeout = 15000) {
+    return fetchJson(`${CU_API.BASE_URL}${path}`, {
+        method: 'POST',
+        timeout,
+        headers: CU_DEFAULT_HEADERS,
+        body: JSON.stringify(body),
+    });
+}
+async function requestCuWebHtml(path, body, apiKey, timeout = 15000) {
+    const form = new URLSearchParams(body);
+    const formText = form.toString();
+    const targetUrl = `${CU_API.WEB_BASE_URL}${path}`;
+    const response = await fetch(`${CU_API.WEB_BASE_URL}${path}`, {
+        method: 'POST',
+        headers: CU_WEB_DEFAULT_HEADERS,
+        body: formText,
+        signal: AbortSignal.timeout(timeout),
+    });
+    if (response.ok) {
+        return response.text();
+    }
+    if (response.status === 400 || response.status === 403 || response.status === 429) {
+        try {
+            const result = await requestByZyte({
+                apiKey,
+                url: targetUrl,
+                timeout,
+                method: 'POST',
+                headers: Object.entries(CU_WEB_DEFAULT_HEADERS).map(([name, value]) => ({ name, value })),
+                bodyText: formText,
+            });
+            if (result.statusCode === 200 && result.httpResponseBody) {
+                return decodeBase64(result.httpResponseBody);
+            }
+        }
+        catch {
+            // 직접 호출 실패 시 Zyte 재시도도 실패하면 원본 에러를 반환합니다.
+        }
+    }
+    throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
+}
+export async function geocodeCuAddress(address, options = {}) {
+    const keyword = address.trim();
+    if (keyword.length === 0) {
+        return null;
+    }
+    const { timeout = 15000, googleMapsApiKey } = options;
+    const apiKey = (googleMapsApiKey || '').trim();
+    if (apiKey.length === 0) {
+        return null;
+    }
+    const endpoint = new URL('https://maps.googleapis.com/maps/api/geocode/json');
+    endpoint.searchParams.set('address', keyword);
+    endpoint.searchParams.set('key', apiKey);
+    const body = await fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout,
+        headers: {
+            Accept: 'application/json',
+        },
+    });
+    if (body.status !== 'OK') {
+        return null;
+    }
+    const firstLocation = body.results?.[0]?.geometry?.location;
+    if (!firstLocation) {
+        return null;
+    }
+    const latitude = toNumber(firstLocation.lat);
+    const longitude = toNumber(firstLocation.lng);
+    if (latitude === 0 || longitude === 0) {
+        return null;
+    }
+    return {
+        latitude,
+        longitude,
+    };
+}
+function decodeHtmlEntities(value) {
+    return value
+        .replace(/ /g, ' ')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+function sanitizeHtmlText(value) {
+    const stripped = value.replace(/<[^>]*>/g, ' ');
+    return decodeHtmlEntities(stripped).replace(/\s+/g, ' ').trim();
+}
+function parseCuWebStores(html) {
+    const rows = html.match(/<tr>[\s\S]*?<\/tr>/g) || [];
+    const stores = [];
+    for (const row of rows) {
+        const nameMatch = row.match(/<span class="name">([\s\S]*?)<\/span>/);
+        if (!nameMatch) {
+            continue;
+        }
+        const phoneMatch = row.match(/<span class="tel">([\s\S]*?)<\/span>/);
+        const addressMatch = row.match(/<address>[\s\S]*?<a [^>]*>([\s\S]*?)<\/a>/);
+        const codeMatch = row.match(/searchLatLng\('[^']*',\s*'([^']+)'\)/);
+        stores.push({
+            storeCode: codeMatch?.[1] || '',
+            storeName: sanitizeHtmlText(nameMatch[1]),
+            phone: sanitizeHtmlText(phoneMatch?.[1] || ''),
+            address: sanitizeHtmlText(addressMatch?.[1] || ''),
+            latitude: 0,
+            longitude: 0,
+            distanceM: 0,
+            stock: 0,
+            deliveryYn: false,
+            pickupYn: false,
+            reserveYn: false,
+        });
+    }
+    return stores;
+}
+function normalizeCuStore(raw) {
+    return {
+        storeCode: raw.storeCd || '',
+        storeName: raw.storeNm || '',
+        phone: raw.storeTelNo || '',
+        address: toStoreAddress(raw),
+        latitude: toNumber(raw.latVal),
+        longitude: toNumber(raw.longVal),
+        distanceM: toNumber(raw.distance),
+        stock: toNumber(raw.stock),
+        deliveryYn: toYnBoolean(raw.deliveryYn) || toYnBoolean(raw.deliveryPickYn),
+        pickupYn: toYnBoolean(raw.jumpoPickYn),
+        reserveYn: toYnBoolean(raw.reserveYn),
+    };
+}
+/**
+ * 좌표 기반 CU 점포 목록을 조회합니다.
+ */
+export async function fetchCuStores(params, options = {}) {
+    const { timeout = 15000, apiKey } = options;
+    const searchWord = (params.searchWord || '').trim();
+    const hasLatitude = typeof params.latitude === 'number' && Number.isFinite(params.latitude);
+    const hasLongitude = typeof params.longitude === 'number' && Number.isFinite(params.longitude);
+    // 좌표가 없고 검색어가 있으면 웹 매장 검색으로 폴백합니다.
+    if (searchWord.length > 0 && (!hasLatitude || !hasLongitude)) {
+        const html = await requestCuWebHtml(CU_API.WEB_STORE_LIST_PATH, {
+            pageIndex: '1',
+            listType: '',
+            jumpoCode: '',
+            jumpoLotto: '',
+            jumpoToto: '',
+            jumpoCash: '',
+            jumpoHour: '',
+            jumpoCafe: '',
+            jumpoDelivery: '',
+            jumpoBakery: '',
+            jumpoFry: '',
+            jumpoMultiDevice: '',
+            jumpoPosCash: '',
+            jumpoBattery: '',
+            jumpoAdderss: '',
+            jumpoSido: '',
+            jumpoGugun: '',
+            jumpodong: '',
+            searchWord,
+        }, apiKey, timeout);
+        const stores = parseCuWebStores(html);
+        return {
+            totalCount: stores.length,
+            stores,
+        };
+    }
+    const latitude = hasLatitude ? params.latitude : 37.5665;
+    const longitude = hasLongitude ? params.longitude : 126.978;
+    const payload = {
+        latVal: String(latitude),
+        longVal: String(longitude),
+        baseLatVal: String(latitude),
+        baseLongVal: String(longitude),
+        tabId: '2',
+        filterSvcList: [],
+        filterAdtList: [],
+        stockCdcYn: 'N',
+        searchStock: false,
+        pickupType: 'change',
+        getRoute: 'IOS',
+        areaTplNo: '0',
+        childMealPickUpYn: 'N',
+        isCurrentSearch: 'N',
+        pageType: params.pageType || 'search_improve',
+        searchWord,
+        isRecommend: params.isRecommend || '',
+        recommendId: params.recommendId || '',
+        jipCd: params.jipCd || params.itemCd || '',
+        itemCd: params.itemCd || '',
+        item_cd: params.itemCd || '',
+        onItemNo: params.onItemNo || '',
+    };
+    const body = await requestCuJson(CU_API.STORE_PATH, payload, timeout);
+    const stores = (body.storeList || []).map((store) => normalizeCuStore(store));
+    return {
+        totalCount: toNumber(body.totalCnt) || stores.length,
+        stores,
+    };
+}
+/**
+ * 재고 검색 전 초기 화면 데이터를 조회합니다.
+ * 정책 변경 시 사전 호출이 필요한 경우를 대비한 워밍업 요청입니다.
+ */
+export async function primeCuStockDisplay(options = {}) {
+    const { timeout = 15000 } = options;
+    await requestCuJson(CU_API.STOCK_DISPLAY_PATH, {}, timeout);
+}
+/**
+ * CU 상품 재고 검색 결과를 조회합니다.
+ */
+export async function fetchCuStock(params, options = {}) {
+    const { timeout = 15000 } = options;
+    try {
+        await primeCuStockDisplay({ timeout });
+    }
+    catch {
+        // 사전 워밍업 실패는 본 검색으로 재시도합니다.
+    }
+    const payload = {
+        searchWord: params.keyword,
+        prevSearchWord: '',
+        spellModifyUseYn: 'Y',
+        offset: params.offset,
+        limit: params.limit,
+        searchSort: params.searchSort,
+    };
+    const body = await requestCuJson(CU_API.STOCK_MAIN_PATH, payload, timeout);
+    const result = body.data?.stockResult?.result;
+    const rows = result?.rows || [];
+    const items = rows
+        .map((row) => row.fields)
+        .filter((fields) => Boolean(fields))
+        .map((fields) => ({
+        itemCode: fields.item_cd || '',
+        onItemNo: fields.on_item_no || '',
+        itemName: fields.item_nm || '',
+        price: toNumber(fields.hyun_maega),
+        pickupYn: toYnBoolean(fields.pickup_yn),
+        deliveryYn: toYnBoolean(fields.deliv_yn),
+        reserveYn: toYnBoolean(fields.reserv_yn),
+    }));
+    return {
+        totalCount: toNumber(result?.total_count) || items.length,
+        spellModifyYn: body.spellModifyYn || 'N',
+        items,
+    };
+}

package/dist/services/cu/index.js

@@ -0,0 +1,21 @@
+/**
+ * CU 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+const CU_METADATA = {
+    id: 'cu',
+    name: 'CU 편의점',
+    version: '1.0.0',
+    description: 'CU 매장 탐색 및 상품 재고 조회 서비스',
+};
+class CuService {
+    metadata = CU_METADATA;
+    getTools() {
+        return [createFindNearbyStoresTool(), createCheckInventoryTool()];
+    }
+}
+export function createCuService() {
+    return new CuService();
+}
+export * from './types.js';