daiso 1.0.0

package/dist/services/daiso/tools/findStores.js

@@ -0,0 +1,145 @@
+/**
+ * 매장 찾기 도구
+ *
+ * 다이소 API를 사용하여 매장을 검색합니다.
+ */
+import * as z from 'zod';
+import { DAISO_WEB_API, formatTime } from '../api.js';
+import { fetchDaisoHtml, fetchDaisoJson } from '../client.js';
+/**
+ * HTML에서 매장 정보 파싱
+ */
+function parseStoresFromHtml(html) {
+    const stores = [];
+    // bx-store div 태그의 시작 위치 찾기
+    const divStartRegex = /<div[^>]*class="bx-store"[^>]*>/gi;
+    let divMatch;
+    while ((divMatch = divStartRegex.exec(html)) !== null) {
+        const startIdx = divMatch.index;
+        const divTag = divMatch[0];
+        // 해당 div의 끝 찾기
+        const endIdx = html.indexOf('<div class="bx-store"', startIdx + 1);
+        const blockEnd = endIdx > 0 ? endIdx : startIdx + 2000;
+        const block = html.slice(startIdx, blockEnd);
+        // data 속성 추출
+        const startMatch = /data-start="(\d+)"/.exec(divTag);
+        const endMatch = /data-end="(\d+)"/.exec(divTag);
+        const latMatch = /data-lat="([^"]+)"/.exec(divTag);
+        const lngMatch = /data-lng="([^"]+)"/.exec(divTag);
+        const infoMatch = /data-info='([^']*)'/.exec(divTag);
+        if (!startMatch || !endMatch || !latMatch || !lngMatch)
+            continue;
+        // 매장명, 전화번호, 주소 추출
+        const nameMatch = /<h4[^>]*class="place"[^>]*>([^<]+)<\/h4>/i.exec(block);
+        const phoneMatch = /<em[^>]*class="phone"[^>]*>([^<]*)<\/em>/i.exec(block);
+        const addrMatch = /<p[^>]*class="addr"[^>]*>([^<]+)<\/p>/i.exec(block);
+        if (!nameMatch)
+            continue;
+        // data-info JSON 파싱
+        let info = {};
+        if (infoMatch) {
+            try {
+                const infoStr = infoMatch[1].replace(/&quot;/g, '"').replace(/&amp;/g, '&');
+                info = JSON.parse(infoStr);
+            }
+            catch {
+                // JSON 파싱 실패 시 빈 객체 사용
+            }
+        }
+        const options = {
+            parking: info.shp_pak === 'Y',
+            ramp: info.entrramp === 'Y',
+            elevator: info.elvtor === 'Y',
+            cashless: info.ptcard === 'Y',
+            photoSticker: info.ptstk === 'Y',
+            nameSticker: info.nmstk === 'Y',
+            simCard: info.usim_yn === 'Y',
+            taxFree: info.tax_free === 'Y',
+            groupOrder: info['ext.group_yn'] === 'Y' || info.group_yn === 'Y',
+            pickup: info.online_yn === 'Y',
+        };
+        stores.push({
+            name: nameMatch[1].trim(),
+            phone: phoneMatch ? phoneMatch[1].replace('T.', '').trim() : '',
+            address: addrMatch ? addrMatch[1].trim() : '',
+            lat: parseFloat(latMatch[1]),
+            lng: parseFloat(lngMatch[1]),
+            openTime: formatTime(startMatch[1]),
+            closeTime: formatTime(endMatch[1]),
+            options,
+        });
+    }
+    return stores;
+}
+/**
+ * 다이소 매장 검색 API 호출
+ */
+export async function fetchStores(keyword, sido, gugun, dong) {
+    const url = new URL(DAISO_WEB_API.SHOP_SEARCH);
+    url.searchParams.set('name_address', keyword || '');
+    url.searchParams.set('sido', sido || '');
+    url.searchParams.set('gugun', gugun || '');
+    url.searchParams.set('dong', dong || '');
+    const html = await fetchDaisoHtml(url.toString());
+    return parseStoresFromHtml(html);
+}
+/**
+ * 시/도별 구/군 목록 조회
+ */
+export async function getDistricts(sido) {
+    const url = new URL(DAISO_WEB_API.SIDO_SEARCH);
+    url.searchParams.set('sido', sido);
+    const data = await fetchDaisoJson(url.toString());
+    return data.map((item) => item.value);
+}
+/**
+ * 구/군별 동 목록 조회
+ */
+export async function getNeighborhoods(sido, gugun) {
+    const url = new URL(DAISO_WEB_API.GUGUN_SEARCH);
+    url.searchParams.set('sido', sido);
+    url.searchParams.set('gugun', gugun);
+    const data = await fetchDaisoJson(url.toString());
+    return data.map((item) => item.value);
+}
+/**
+ * 매장 검색 핸들러
+ */
+async function findStores(args) {
+    const { keyword, sido, gugun, dong, limit = 50 } = args;
+    // 최소한 하나의 검색 조건이 필요
+    if (!keyword && !sido) {
+        throw new Error('검색어(keyword) 또는 지역(sido)을 입력해주세요.');
+    }
+    const stores = await fetchStores(keyword, sido, gugun, dong);
+    const limitedStores = stores.slice(0, limit);
+    const result = {
+        searchParams: { keyword, sido, gugun, dong },
+        totalCount: stores.length,
+        count: limitedStores.length,
+        stores: limitedStores,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * 도구 등록 정보 생성
+ */
+export function createFindStoresTool() {
+    return {
+        name: 'daiso_find_stores',
+        metadata: {
+            title: '매장 검색',
+            description: '다이소 매장을 검색합니다. 키워드(매장명, 주소) 또는 지역(시도/구군/동)으로 검색할 수 있습니다.',
+            inputSchema: {
+                keyword: z.string().optional().describe('검색할 매장명 또는 주소 키워드 (예: 강남, 홍대)'),
+                sido: z.string().optional().describe('시/도 (예: 서울, 경기, 부산)'),
+                gugun: z.string().optional().describe('구/군 (예: 강남구, 마포구)'),
+                dong: z.string().optional().describe('동 (예: 역삼동, 합정동)'),
+                limit: z.number().optional().default(50).describe('반환할 최대 매장 수 (기본값: 50)'),
+            },
+        },
+        handler: findStores,
+    };
+}

package/dist/services/daiso/tools/getPriceInfo.js

@@ -0,0 +1,90 @@
+/**
+ * 가격 정보 조회 도구
+ *
+ * 다이소몰 API를 사용하여 상품의 가격 정보를 조회합니다.
+ */
+import * as z from 'zod';
+import { DAISOMALL_API, getImageUrl } from '../api.js';
+import { fetchDaisoJson } from '../client.js';
+/**
+ * 상품 ID로 검색
+ */
+export async function fetchProductById(productId) {
+    const url = new URL(DAISOMALL_API.SEARCH_PRODUCTS);
+    url.searchParams.set('searchTerm', productId);
+    url.searchParams.set('cntPerPage', '10');
+    url.searchParams.set('pageNum', '1');
+    const data = await fetchDaisoJson(url.toString());
+    if (!data.resultSet?.result?.[0]?.resultDocuments) {
+        return null;
+    }
+    const docs = data.resultSet.result[0].resultDocuments;
+    // 정확한 ID 매칭 시도
+    const exactMatch = docs.find((doc) => doc.PD_NO === productId);
+    if (exactMatch) {
+        return exactMatch;
+    }
+    return docs.length > 0 ? docs[0] : null;
+}
+/**
+ * 상품명으로 검색
+ */
+async function fetchProductByName(productName) {
+    const url = new URL(DAISOMALL_API.SEARCH_PRODUCTS);
+    url.searchParams.set('searchTerm', productName);
+    url.searchParams.set('cntPerPage', '1');
+    url.searchParams.set('pageNum', '1');
+    const data = await fetchDaisoJson(url.toString());
+    if (!data.resultSet?.result?.[0]?.resultDocuments?.length) {
+        return null;
+    }
+    return data.resultSet.result[0].resultDocuments[0];
+}
+/**
+ * 가격 정보 조회 핸들러
+ */
+async function getPriceInfo(args) {
+    const { productId, productName } = args;
+    if (!productId && !productName) {
+        throw new Error('상품 ID(productId) 또는 상품명(productName)을 입력해주세요.');
+    }
+    let product = null;
+    // productId가 있으면 ID로 검색, 없으면 productName으로 검색
+    // 위에서 둘 다 없는 경우는 이미 에러 처리됨
+    product = productId
+        ? await fetchProductById(productId)
+        : await fetchProductByName(productName);
+    if (!product) {
+        throw new Error(`상품을 찾을 수 없습니다: ${productId || productName}`);
+    }
+    const price = parseInt(product.PD_PRC) || 0;
+    const result = {
+        productId: product.PD_NO,
+        productName: product.PDNM || product.EXH_PD_NM,
+        currentPrice: price,
+        currency: 'KRW',
+        imageUrl: getImageUrl(product.ATCH_FILE_URL),
+        brand: product.BRND_NM || undefined,
+        soldOut: product.SOLD_OUT_YN === 'Y',
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * 도구 등록 정보 생성
+ */
+export function createGetPriceInfoTool() {
+    return {
+        name: 'daiso_get_price_info',
+        metadata: {
+            title: '가격 정보',
+            description: '제품의 가격 정보를 조회합니다. 제품 ID 또는 제품명으로 조회할 수 있습니다.',
+            inputSchema: {
+                productId: z.string().optional().describe('제품 ID'),
+                productName: z.string().optional().describe('제품명 (productId가 없을 경우 사용)'),
+            },
+        },
+        handler: getPriceInfo,
+    };
+}

package/dist/services/daiso/tools/searchProducts.js

@@ -0,0 +1,74 @@
+/**
+ * 제품 검색 도구
+ *
+ * 다이소몰 API를 사용하여 제품을 검색합니다.
+ */
+import * as z from 'zod';
+import { DAISOMALL_API, getImageUrl } from '../api.js';
+import { fetchDaisoJson } from '../client.js';
+/**
+ * 다이소몰 API에서 상품 검색
+ */
+export async function fetchProducts(query, page = 1, pageSize = 30) {
+    const url = new URL(DAISOMALL_API.SEARCH_PRODUCTS);
+    url.searchParams.set('searchTerm', query);
+    url.searchParams.set('cntPerPage', pageSize.toString());
+    url.searchParams.set('pageNum', page.toString());
+    const data = await fetchDaisoJson(url.toString());
+    // 결과가 없는 경우
+    if (!data.resultSet?.result?.[0]?.resultDocuments) {
+        return { products: [], totalCount: 0 };
+    }
+    const result = data.resultSet.result[0];
+    const totalCount = result.totalSize || 0;
+    const products = result.resultDocuments.map((doc) => ({
+        id: doc.PD_NO,
+        name: doc.PDNM || doc.EXH_PD_NM || '',
+        price: parseInt(doc.PD_PRC) || 0,
+        imageUrl: getImageUrl(doc.ATCH_FILE_URL),
+        brand: doc.BRND_NM || undefined,
+        soldOut: doc.SOLD_OUT_YN === 'Y',
+        isNew: doc.NEW_PD_YN === 'Y',
+        pickupAvailable: doc.PKUP_OR_PSBL_YN === 'Y',
+    }));
+    return { products, totalCount };
+}
+/**
+ * 제품 검색 핸들러
+ */
+async function searchProducts(args) {
+    const { query, page = 1, pageSize = 30 } = args;
+    if (!query || query.trim().length === 0) {
+        throw new Error('검색어를 입력해주세요.');
+    }
+    const { products, totalCount } = await fetchProducts(query, page, pageSize);
+    const result = {
+        query,
+        page,
+        pageSize,
+        totalCount,
+        count: products.length,
+        products,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * 도구 등록 정보 생성
+ */
+export function createSearchProductsTool() {
+    return {
+        name: 'daiso_search_products',
+        metadata: {
+            title: '제품 검색',
+            description: '다이소 제품을 검색합니다. 키워드로 제품을 검색할 수 있습니다.',
+            inputSchema: {
+                query: z.string().describe('검색할 제품명 또는 키워드'),
+                page: z.number().optional().default(1).describe('페이지 번호 (기본값: 1)'),
+                pageSize: z.number().optional().default(30).describe('페이지당 결과 수 (기본값: 30)'),
+            },
+        },
+        handler: searchProducts,
+    };
+}

package/dist/services/daiso/types.js

@@ -0,0 +1,4 @@
+/**
+ * 다이소 서비스 전용 타입 정의
+ */
+export {};

package/dist/services/megabox/api.js

@@ -0,0 +1,8 @@
+/**
+ * 메가박스 API 엔드포인트 중앙 관리
+ */
+export const MEGABOX_API = {
+    BASE_URL: 'https://www.megabox.co.kr',
+    SELECT_BOOKING_LIST_PATH: '/on/oh/ohb/SimpleBooking/selectBokdList.do',
+    THEATER_INFO_PATH: '/on/oh/ohc/Brch/infoPage.do',
+};

package/dist/services/megabox/client.js

@@ -0,0 +1,140 @@
+/**
+ * 메가박스 API 클라이언트
+ */
+import { MEGABOX_API } from './api.js';
+import { formatTime, toNumber, toYyyymmdd } from '../../utils/format.js';
+import { createTimeoutController } from '../../utils/http.js';
+export async function fetchMegaboxBookingList(params) {
+    const { timeout = 15000 } = params;
+    const form = new URLSearchParams({
+        playDe: params.playDate,
+        sellChnlCd: 'ONLINE',
+        brchNoListCnt: '1',
+        areaCd1: params.areaCode || '11',
+        spclbYn1: 'N',
+        theabKindCd1: '',
+    });
+    if (params.movieId) {
+        form.set('arrMovieNo', params.movieId);
+    }
+    if (params.theaterId) {
+        form.set('brchNo1', params.theaterId);
+    }
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    try {
+        const response = await fetch(`${MEGABOX_API.BASE_URL}${MEGABOX_API.SELECT_BOOKING_LIST_PATH}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                Accept: 'application/json, text/javascript, */*; q=0.01',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+            body: form.toString(),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`메가박스 상영 목록 조회 실패: ${response.status}`);
+        }
+        const body = (await response.json());
+        const theaters = (body.areaBrchList || [])
+            .filter((item) => item.brchNo && item.brchNm)
+            .map((item) => ({
+            theaterId: item.brchNo,
+            theaterName: item.brchNm,
+        }));
+        const movies = (body.movieList || [])
+            .filter((item) => item.movieNo && item.movieNm)
+            .map((item) => ({
+            movieId: item.movieNo,
+            movieName: item.movieNm,
+            movieStatus: item.movieStatCdNm || undefined,
+        }));
+        const showtimes = (body.movieFormList || [])
+            .filter((item) => item.playSchdlNo && item.movieNo && item.brchNo)
+            .map((item) => ({
+            scheduleId: item.playSchdlNo,
+            movieId: item.movieNo,
+            movieName: item.movieNm || '',
+            theaterId: item.brchNo,
+            theaterName: item.brchNm || '',
+            playDate: item.playDe || params.playDate,
+            startTime: formatTime(item.playStartTime),
+            endTime: formatTime(item.playEndTime),
+            totalSeats: toNumber(item.totSeatCnt),
+            remainingSeats: toNumber(item.restSeatCnt),
+        }));
+        return {
+            theaters,
+            movies,
+            showtimes,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('메가박스 상영 목록 조회 시간 초과');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+function parseCoordinates(html) {
+    const latMatch = html.match(/(?:lat=|mapLat\s*[:=]\s*["']?)(-?\d+\.\d+)/i);
+    const lngMatch = html.match(/(?:lng=|mapLng\s*[:=]\s*["']?)(-?\d+\.\d+)/i);
+    return {
+        latitude: latMatch ? parseFloat(latMatch[1]) : null,
+        longitude: lngMatch ? parseFloat(lngMatch[1]) : null,
+    };
+}
+function parseAddress(html) {
+    const roadAddressMatch = html.match(/도로명주소<\/dt>\s*<dd>([^<]+)<\/dd>/i);
+    if (roadAddressMatch) {
+        return roadAddressMatch[1].trim();
+    }
+    const addressMatch = html.match(/주소<\/dt>\s*<dd>([^<]+)<\/dd>/i);
+    if (addressMatch) {
+        return addressMatch[1].trim();
+    }
+    return '';
+}
+export async function fetchMegaboxTheaterInfo(theaterId, timeout = 15000) {
+    const form = new URLSearchParams({
+        brchNo: theaterId,
+    });
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    try {
+        const response = await fetch(`${MEGABOX_API.BASE_URL}${MEGABOX_API.THEATER_INFO_PATH}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+                Accept: 'text/html, */*; q=0.01',
+                'X-Requested-With': 'XMLHttpRequest',
+            },
+            body: form.toString(),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`메가박스 지점 정보 조회 실패: ${response.status}`);
+        }
+        const html = await response.text();
+        const coordinates = parseCoordinates(html);
+        const address = parseAddress(html);
+        return {
+            theaterId,
+            address,
+            latitude: coordinates.latitude,
+            longitude: coordinates.longitude,
+        };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('메가박스 지점 정보 조회 시간 초과');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export { toYyyymmdd };

package/dist/services/megabox/index.js

@@ -0,0 +1,26 @@
+/**
+ * 메가박스 서비스 프로바이더
+ */
+import { createFindNearbyTheatersTool } from './tools/findNearbyTheaters.js';
+import { createListNowShowingTool } from './tools/listNowShowing.js';
+import { createGetRemainingSeatsTool } from './tools/getRemainingSeats.js';
+const MEGABOX_METADATA = {
+    id: 'megabox',
+    name: '메가박스',
+    version: '1.0.0',
+    description: '메가박스 주변 지점 탐색, 영화 목록 조회, 잔여 좌석 조회 서비스',
+};
+class MegaboxService {
+    metadata = MEGABOX_METADATA;
+    getTools() {
+        return [
+            createFindNearbyTheatersTool(),
+            createListNowShowingTool(),
+            createGetRemainingSeatsTool(),
+        ];
+    }
+}
+export function createMegaboxService() {
+    return new MegaboxService();
+}
+export * from './types.js';

package/dist/services/megabox/tools/findNearbyTheaters.js

@@ -0,0 +1,74 @@
+/**
+ * 메가박스 주변 지점 탐색 도구
+ */
+import * as z from 'zod';
+import { fetchMegaboxBookingList, fetchMegaboxTheaterInfo, toYyyymmdd } from '../client.js';
+function calculateDistanceKm(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return 6371 * c;
+}
+async function findNearbyTheaters(args) {
+    const { latitude = 37.5665, longitude = 126.978, playDate = toYyyymmdd(), areaCode = '11', limit = 10, timeoutMs = 15000, } = args;
+    const { theaters } = await fetchMegaboxBookingList({
+        playDate,
+        areaCode,
+        timeout: timeoutMs,
+    });
+    const infoResults = await Promise.allSettled(theaters.map((theater) => fetchMegaboxTheaterInfo(theater.theaterId, timeoutMs)));
+    const merged = theaters
+        .map((theater, index) => {
+        const infoResult = infoResults[index];
+        if (infoResult.status !== 'fulfilled') {
+            return null;
+        }
+        const info = infoResult.value;
+        if (info.latitude === null || info.longitude === null) {
+            return null;
+        }
+        const distanceKm = calculateDistanceKm(latitude, longitude, info.latitude, info.longitude);
+        return {
+            theaterId: theater.theaterId,
+            theaterName: theater.theaterName,
+            address: info.address,
+            latitude: info.latitude,
+            longitude: info.longitude,
+            distanceKm: Number(distanceKm.toFixed(2)),
+        };
+    })
+        .filter((theater) => theater !== null)
+        .sort((a, b) => a.distanceKm - b.distanceKm)
+        .slice(0, limit);
+    const result = {
+        location: { latitude, longitude },
+        playDate,
+        areaCode,
+        count: merged.length,
+        theaters: merged,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createFindNearbyTheatersTool() {
+    return {
+        name: 'megabox_find_nearby_theaters',
+        metadata: {
+            title: '메가박스 주변 지점 탐색',
+            description: '사용자 좌표 기준으로 메가박스 지점을 거리순으로 조회합니다.',
+            inputSchema: {
+                latitude: z.number().optional().default(37.5665).describe('위도 (기본값: 서울 시청 37.5665)'),
+                longitude: z.number().optional().default(126.978).describe('경도 (기본값: 서울 시청 126.978)'),
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
+                limit: z.number().optional().default(10).describe('반환할 최대 지점 수 (기본값: 10)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: findNearbyTheaters,
+    };
+}

package/dist/services/megabox/tools/getRemainingSeats.js

@@ -0,0 +1,57 @@
+/**
+ * 메가박스 잔여 좌석 조회 도구
+ */
+import * as z from 'zod';
+import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
+async function getRemainingSeats(args) {
+    const { playDate = toYyyymmdd(), theaterId, movieId, areaCode = '11', limit = 50, timeoutMs = 15000, } = args;
+    const { showtimes } = await fetchMegaboxBookingList({
+        playDate,
+        theaterId,
+        movieId,
+        areaCode,
+        timeout: timeoutMs,
+    });
+    const filteredShowtimes = showtimes
+        .filter((item) => (theaterId ? item.theaterId === theaterId : true))
+        .filter((item) => (movieId ? item.movieId === movieId : true))
+        .sort((a, b) => {
+        if (a.startTime === b.startTime) {
+            return a.theaterName.localeCompare(b.theaterName);
+        }
+        return a.startTime.localeCompare(b.startTime);
+    })
+        .slice(0, limit);
+    const result = {
+        playDate,
+        filters: {
+            theaterId: theaterId || null,
+            movieId: movieId || null,
+            areaCode,
+            limit,
+        },
+        count: filteredShowtimes.length,
+        seats: filteredShowtimes,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createGetRemainingSeatsTool() {
+    return {
+        name: 'megabox_get_remaining_seats',
+        metadata: {
+            title: '메가박스 잔여 좌석 조회',
+            description: '영화/지점/날짜 조건으로 상영 회차별 남은 좌석 수를 조회합니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterId: z.string().optional().describe('메가박스 지점 번호 (예: 1372)'),
+                movieId: z.string().optional().describe('메가박스 영화 번호 (예: 25104500)'),
+                areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
+                limit: z.number().optional().default(50).describe('반환할 최대 회차 수 (기본값: 50)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: getRemainingSeats,
+    };
+}

package/dist/services/megabox/tools/listNowShowing.js

@@ -0,0 +1,51 @@
+/**
+ * 메가박스 영화 목록 조회 도구
+ */
+import * as z from 'zod';
+import { fetchMegaboxBookingList, toYyyymmdd } from '../client.js';
+async function listNowShowing(args) {
+    const { playDate = toYyyymmdd(), theaterId, movieId, areaCode = '11', timeoutMs = 15000, } = args;
+    const { theaters, movies, showtimes } = await fetchMegaboxBookingList({
+        playDate,
+        theaterId,
+        movieId,
+        areaCode,
+        timeout: timeoutMs,
+    });
+    const result = {
+        playDate,
+        filters: {
+            theaterId: theaterId || null,
+            movieId: movieId || null,
+            areaCode,
+        },
+        counts: {
+            theaters: theaters.length,
+            movies: movies.length,
+            showtimes: showtimes.length,
+        },
+        theaters,
+        movies,
+        showtimes,
+    };
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function createListNowShowingTool() {
+    return {
+        name: 'megabox_list_now_showing',
+        metadata: {
+            title: '메가박스 영화 목록 조회',
+            description: '날짜/지점 조건으로 메가박스 영화 및 상영 회차 목록을 조회합니다.',
+            inputSchema: {
+                playDate: z.string().optional().describe('조회 날짜(YYYYMMDD, 기본값: 오늘)'),
+                theaterId: z.string().optional().describe('메가박스 지점 번호 (예: 1372)'),
+                movieId: z.string().optional().describe('메가박스 영화 번호 (예: 25104500)'),
+                areaCode: z.string().optional().default('11').describe('지역 코드 (기본값: 11, 서울)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: listNowShowing,
+    };
+}

package/dist/services/megabox/types.js

@@ -0,0 +1,4 @@
+/**
+ * 메가박스 서비스 전용 타입 정의
+ */
+export {};