| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300 |
- import asyncio
- from datetime import date
- from fastmcp import FastMCP
- from room_cal._utils import services as _services, safe_json_loads, iter_dates
- from room_cal.store import DEFAULT_CALENDAR_NAME
- from room_cal._health import caldav_checks, credentials_checks
- from room_cal.pricing import CalPrice
- from room_cal.pricing.calc import (
- net_to_list, list_to_net, list_to_retail,
- retail_to_list, net_to_retail, retail_to_net,
- )
- from room_cal.reservations import Reservation
- from room_cal.closed import Closed
- from room_cal.discount import Discount
- mcp = FastMCP('room_cal')
- _CALC_FROM = {
- 'net_to_list': 'net', 'net_to_retail': 'net',
- 'list_to_net': 'list', 'list_to_retail': 'list',
- 'retail_to_list': 'retail', 'retail_to_net': 'retail',
- }
- _API_SOURCE = {'domain': 'mcp', 'id': ''}
- @mcp.tool()
- async def health_check() -> dict:
- """Check CalDAV connection, room calendar reachability, and service credential validity. Returns {caldav_connection, calendar, credentials}."""
- (conn, cal_result), creds = await asyncio.gather(
- caldav_checks(DEFAULT_CALENDAR_NAME),
- credentials_checks(),
- )
- return {
- 'caldav_connection': conn.to_dict(),
- 'calendar': cal_result.to_dict(),
- 'credentials': {k: v.to_dict() for k, v in creds.items()},
- }
- @mcp.tool()
- async def list_services() -> list[dict]:
- return [{'key': s.key, 'name': s.name} for s in _services()]
- @mcp.tool()
- async def convert_price(transformation: str, service: str, amount: int) -> dict:
- """Convert a price. transformation: net_to_list, list_to_net, list_to_retail, retail_to_list, net_to_retail, retail_to_net. Returns {net, list, retail}."""
- from_type = _CALC_FROM.get(transformation)
- if from_type is None:
- raise ValueError(f'Unknown transformation: {transformation!r}')
- if from_type == 'net':
- return {'net': amount, 'list': net_to_list(service, amount), 'retail': net_to_retail(service, amount)}
- if from_type == 'list':
- return {'net': list_to_net(service, amount), 'list': amount, 'retail': list_to_retail(service, amount)}
- return {'net': retail_to_net(service, amount), 'list': retail_to_list(service, amount), 'retail': amount}
- @mcp.tool()
- async def get_prices(start_date: str, end_date: str) -> dict:
- """Get price dicts for a date range (YYYY-MM-DD). Returns a dict keyed by date string; None for dates with no price set."""
- price_range = await CalPrice(DEFAULT_CALENDAR_NAME).get(date.fromisoformat(start_date), date.fromisoformat(end_date))
- return {k: v.to_dict() if v else None for k, v in price_range.items()}
- @mcp.tool()
- async def set_price(target_date: str, value: float) -> None:
- """Set the net price for a date (YYYY-MM-DD)."""
- await CalPrice(DEFAULT_CALENDAR_NAME).set(date.fromisoformat(target_date), value)
- @mcp.tool()
- async def get_reservation(target_date: str) -> dict | None:
- """Get the reservation covering a date (checkin ≤ date < checkout), or null."""
- d = date.fromisoformat(target_date)
- for ev in await Reservation(DEFAULT_CALENDAR_NAME).list(d, d):
- if ev['start'].date() <= d < ev['end'].date():
- xd = safe_json_loads(ev['x_data']) or {}
- xd['checkin_date'] = ev['start'].date().isoformat()
- xd['checkout_date'] = ev['end'].date().isoformat()
- return xd
- return None
- @mcp.tool()
- async def get_reservations_range(start_date: str, end_date: str) -> dict:
- """Get reservations for each date in a range. Returns {date: dict or null}."""
- start = date.fromisoformat(start_date)
- end = date.fromisoformat(end_date)
- events = await Reservation(DEFAULT_CALENDAR_NAME).list(start, end)
- result: dict[str, dict | None] = {str(d): None for d in iter_dates(start, end)}
- for ev in events:
- checkin = ev['start'].date()
- checkout = ev['end'].date()
- xd = safe_json_loads(ev['x_data']) or {}
- xd['checkin_date'] = checkin.isoformat()
- xd['checkout_date'] = checkout.isoformat()
- for d in iter_dates(start, end):
- if checkin <= d < checkout:
- result[str(d)] = xd
- return result
- @mcp.tool()
- async def get_closed(target_date: str) -> list[str]:
- """Get closed service keys for a date. Empty list means open."""
- return await Closed(DEFAULT_CALENDAR_NAME).get(date.fromisoformat(target_date)) or []
- @mcp.tool()
- async def get_closed_range(start_date: str, end_date: str) -> dict:
- """Get closed services for each date in a range. Returns {date: [service, ...]}."""
- start = date.fromisoformat(start_date)
- end = date.fromisoformat(end_date)
- events = await Closed(DEFAULT_CALENDAR_NAME).list(start, end)
- by_date: dict[str, list] = {str(d): [] for d in iter_dates(start, end)}
- for ev in events:
- d = ev['start'].date()
- if start <= d <= end:
- xd = safe_json_loads(ev['x_data'])
- by_date[str(d)] = (xd or {}).get('closed_services', [])
- return by_date
- @mcp.tool()
- async def set_closed(target_date: str, services: list[str]) -> None:
- """Block a date for the given services. Empty list unblocks the date."""
- await Closed(DEFAULT_CALENDAR_NAME).set(date.fromisoformat(target_date), services, source=_API_SOURCE)
- @mcp.tool()
- async def get_discount(target_date: str) -> dict | None:
- """Get discount for a date, or null if none set."""
- return await Discount(DEFAULT_CALENDAR_NAME).get(date.fromisoformat(target_date))
- @mcp.tool()
- async def get_discounts_range(start_date: str, end_date: str) -> dict:
- """Get discounts for each date in a range. Returns {date: {type, value} or null}."""
- start = date.fromisoformat(start_date)
- end = date.fromisoformat(end_date)
- events = await Discount(DEFAULT_CALENDAR_NAME).list(start, end)
- by_date: dict[str, dict | None] = {str(d): None for d in iter_dates(start, end)}
- for ev in events:
- d = ev['start'].date()
- if start <= d <= end:
- xd = safe_json_loads(ev['x_data'])
- if xd:
- by_date[str(d)] = {'type': xd.get('type'), 'value': xd.get('value')}
- return by_date
- @mcp.tool()
- async def set_discount(target_date: str, discount_type: str, value: int) -> None:
- """Set a discount. discount_type: 'percent' or 'flat'."""
- await Discount(DEFAULT_CALENDAR_NAME).set(
- date.fromisoformat(target_date), discount_type, value, source=_API_SOURCE
- )
- @mcp.tool()
- async def delete_discount(target_date: str) -> None:
- """Remove the discount on a date."""
- await Discount(DEFAULT_CALENDAR_NAME).delete_on(date.fromisoformat(target_date))
- @mcp.tool()
- async def refresh_credentials(service: str | None = None) -> dict:
- """Trigger automatic credential refresh via Playwright. service: optional key (e.g. 'booking', 'airbnb'); omit to refresh all. Booking.com includes messaging 2FA and may take 2+ minutes. Returns {refreshed: [...], errors: {key: reason}}."""
- from room_cal.service_api._scripts import refresh_service
- from room_cal.service_api.types import ServiceAuthError
- keys = [service] if service else [s.key for s in _services()]
- loop = asyncio.get_running_loop()
- async def _do(key: str) -> tuple[str, str | None]:
- try:
- await loop.run_in_executor(None, refresh_service, key)
- return key, None
- except (ServiceAuthError, Exception) as e:
- return key, str(e)
- results = await asyncio.gather(*[_do(k) for k in keys])
- return {
- 'refreshed': [k for k, err in results if err is None],
- 'errors': {k: err for k, err in results if err is not None},
- }
- @mcp.tool()
- async def reload_caches() -> dict:
- """Clear all in-memory CalDAV event caches so the next request re-fetches from the server. Returns {cleared_calendars}."""
- from room_cal.store import clear_caches
- count = clear_caches()
- return {'cleared_calendars': count}
- @mcp.tool()
- async def get_chat_thread(service_key: str, chat_id: str) -> dict:
- """Fetch recent messages for a reservation thread. Returns {chat_id, messages: [{id, created_at, body, sender}], is_reply_needed?}."""
- from room_cal.service_api import ServiceAPI
- from room_cal.service_api.types import ServiceAuthError
- api = ServiceAPI()
- try:
- client = api.chat_client(service_key)
- except KeyError:
- raise ValueError(f'unknown service: {service_key!r}')
- except TypeError:
- raise ValueError(f'{service_key!r} does not support chat')
- try:
- thread = await client.get_thread(chat_id)
- except ServiceAuthError as e:
- raise RuntimeError(f'auth error: {e}')
- chat_id_out = getattr(thread, 'thread_id', None) or getattr(thread, 'reservation_id', None)
- result: dict = {
- 'chat_id': chat_id_out,
- 'messages': [
- {
- 'id': m.id,
- 'created_at': getattr(m, 'created_at_ms', None) or getattr(m, 'created_at', None),
- 'body': m.body,
- 'sender': getattr(m, 'sender_account_id', None) or getattr(m, 'sender', None),
- }
- for m in thread.messages
- ],
- }
- if hasattr(thread, 'is_reply_needed'):
- result['is_reply_needed'] = thread.is_reply_needed
- return result
- @mcp.tool()
- async def chat_send_ready(service_key: str) -> dict:
- """Check whether sending messages is currently available for a service. Returns {ready: bool}."""
- from room_cal.service_api import ServiceAPI
- api = ServiceAPI()
- try:
- client = api.chat_client(service_key)
- except KeyError:
- raise ValueError(f'unknown service: {service_key!r}')
- except TypeError:
- raise ValueError(f'{service_key!r} does not support chat')
- return {'ready': client.send_ready()}
- @mcp.tool()
- async def send_chat_message(service_key: str, chat_id: str, body: str) -> None:
- """Send a text message to a guest conversation thread."""
- from room_cal.service_api import ServiceAPI
- from room_cal.service_api.types import ServiceAuthError
- api = ServiceAPI()
- try:
- client = api.chat_client(service_key)
- except KeyError:
- raise ValueError(f'unknown service: {service_key!r}')
- except TypeError:
- raise ValueError(f'{service_key!r} does not support chat')
- try:
- await client.send_message(chat_id, body)
- except ServiceAuthError as e:
- raise RuntimeError(f'auth error: {e}')
- import importlib
- import pkgutil
- import room_cal.actions as _actions_pkg
- _ACTIONS: dict[str, tuple[str, str, list[str]]] = {}
- for _info in pkgutil.iter_modules(_actions_pkg.__path__):
- if _info.name.startswith('_'):
- continue
- _mod = importlib.import_module(f'room_cal.actions.{_info.name}')
- _spec = getattr(_mod, 'ACTION_SPEC', None)
- if _spec:
- _route_name, _allowed_keys = _spec
- _ACTIONS[_route_name] = (f'room_cal.actions.{_info.name}', _info.name, _allowed_keys)
- @mcp.tool()
- async def run_action(
- action: str,
- start_date: str,
- end_date: str | None = None,
- feed_name: str | None = None,
- title: str | None = None,
- service: str | None = None,
- weekday: int | None = None,
- weekend: int | None = None,
- ) -> object:
- """Run a room_cal action over a date range. action must be one of the names in _ACTIONS (auto-discovered from room_cal.actions). Optional kwargs: feed_name, title (fetch-feed); service (fetch-prices); weekday, weekend (fill-prices)."""
- from datetime import date as _date
- if action not in _ACTIONS:
- raise ValueError(f'Unknown action: {action!r}')
- module_path, fn_name, allowed_keys = _ACTIONS[action]
- mod = importlib.import_module(module_path)
- fn = getattr(mod, fn_name)
- start = _date.fromisoformat(start_date)
- end = _date.fromisoformat(end_date) if end_date else start
- all_kwargs = {'feed_name': feed_name, 'title': title, 'service': service, 'weekday': weekday, 'weekend': weekend}
- kwargs = {k: v for k, v in all_kwargs.items() if k in allowed_keys and v is not None}
- return await fn(start, end, **kwargs)
|