__init__.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300
  1. import asyncio
  2. from datetime import date
  3. from fastmcp import FastMCP
  4. from room_cal._utils import services as _services, safe_json_loads, iter_dates
  5. from room_cal.store import DEFAULT_CALENDAR_NAME
  6. from room_cal._health import caldav_checks, credentials_checks
  7. from room_cal.pricing import CalPrice
  8. from room_cal.pricing.calc import (
  9. net_to_list, list_to_net, list_to_retail,
  10. retail_to_list, net_to_retail, retail_to_net,
  11. )
  12. from room_cal.reservations import Reservation
  13. from room_cal.closed import Closed
  14. from room_cal.discount import Discount
  15. mcp = FastMCP('room_cal')
  16. _CALC_FROM = {
  17. 'net_to_list': 'net', 'net_to_retail': 'net',
  18. 'list_to_net': 'list', 'list_to_retail': 'list',
  19. 'retail_to_list': 'retail', 'retail_to_net': 'retail',
  20. }
  21. _API_SOURCE = {'domain': 'mcp', 'id': ''}
  22. @mcp.tool()
  23. async def health_check() -> dict:
  24. """Check CalDAV connection, room calendar reachability, and service credential validity. Returns {caldav_connection, calendar, credentials}."""
  25. (conn, cal_result), creds = await asyncio.gather(
  26. caldav_checks(DEFAULT_CALENDAR_NAME),
  27. credentials_checks(),
  28. )
  29. return {
  30. 'caldav_connection': conn.to_dict(),
  31. 'calendar': cal_result.to_dict(),
  32. 'credentials': {k: v.to_dict() for k, v in creds.items()},
  33. }
  34. @mcp.tool()
  35. async def list_services() -> list[dict]:
  36. return [{'key': s.key, 'name': s.name} for s in _services()]
  37. @mcp.tool()
  38. async def convert_price(transformation: str, service: str, amount: int) -> dict:
  39. """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}."""
  40. from_type = _CALC_FROM.get(transformation)
  41. if from_type is None:
  42. raise ValueError(f'Unknown transformation: {transformation!r}')
  43. if from_type == 'net':
  44. return {'net': amount, 'list': net_to_list(service, amount), 'retail': net_to_retail(service, amount)}
  45. if from_type == 'list':
  46. return {'net': list_to_net(service, amount), 'list': amount, 'retail': list_to_retail(service, amount)}
  47. return {'net': retail_to_net(service, amount), 'list': retail_to_list(service, amount), 'retail': amount}
  48. @mcp.tool()
  49. async def get_prices(start_date: str, end_date: str) -> dict:
  50. """Get price dicts for a date range (YYYY-MM-DD). Returns a dict keyed by date string; None for dates with no price set."""
  51. price_range = await CalPrice(DEFAULT_CALENDAR_NAME).get(date.fromisoformat(start_date), date.fromisoformat(end_date))
  52. return {k: v.to_dict() if v else None for k, v in price_range.items()}
  53. @mcp.tool()
  54. async def set_price(target_date: str, value: float) -> None:
  55. """Set the net price for a date (YYYY-MM-DD)."""
  56. await CalPrice(DEFAULT_CALENDAR_NAME).set(date.fromisoformat(target_date), value)
  57. @mcp.tool()
  58. async def get_reservation(target_date: str) -> dict | None:
  59. """Get the reservation covering a date (checkin ≤ date < checkout), or null."""
  60. d = date.fromisoformat(target_date)
  61. for ev in await Reservation(DEFAULT_CALENDAR_NAME).list(d, d):
  62. if ev['start'].date() <= d < ev['end'].date():
  63. xd = safe_json_loads(ev['x_data']) or {}
  64. xd['checkin_date'] = ev['start'].date().isoformat()
  65. xd['checkout_date'] = ev['end'].date().isoformat()
  66. return xd
  67. return None
  68. @mcp.tool()
  69. async def get_reservations_range(start_date: str, end_date: str) -> dict:
  70. """Get reservations for each date in a range. Returns {date: dict or null}."""
  71. start = date.fromisoformat(start_date)
  72. end = date.fromisoformat(end_date)
  73. events = await Reservation(DEFAULT_CALENDAR_NAME).list(start, end)
  74. result: dict[str, dict | None] = {str(d): None for d in iter_dates(start, end)}
  75. for ev in events:
  76. checkin = ev['start'].date()
  77. checkout = ev['end'].date()
  78. xd = safe_json_loads(ev['x_data']) or {}
  79. xd['checkin_date'] = checkin.isoformat()
  80. xd['checkout_date'] = checkout.isoformat()
  81. for d in iter_dates(start, end):
  82. if checkin <= d < checkout:
  83. result[str(d)] = xd
  84. return result
  85. @mcp.tool()
  86. async def get_closed(target_date: str) -> list[str]:
  87. """Get closed service keys for a date. Empty list means open."""
  88. return await Closed(DEFAULT_CALENDAR_NAME).get(date.fromisoformat(target_date)) or []
  89. @mcp.tool()
  90. async def get_closed_range(start_date: str, end_date: str) -> dict:
  91. """Get closed services for each date in a range. Returns {date: [service, ...]}."""
  92. start = date.fromisoformat(start_date)
  93. end = date.fromisoformat(end_date)
  94. events = await Closed(DEFAULT_CALENDAR_NAME).list(start, end)
  95. by_date: dict[str, list] = {str(d): [] for d in iter_dates(start, end)}
  96. for ev in events:
  97. d = ev['start'].date()
  98. if start <= d <= end:
  99. xd = safe_json_loads(ev['x_data'])
  100. by_date[str(d)] = (xd or {}).get('closed_services', [])
  101. return by_date
  102. @mcp.tool()
  103. async def set_closed(target_date: str, services: list[str]) -> None:
  104. """Block a date for the given services. Empty list unblocks the date."""
  105. await Closed(DEFAULT_CALENDAR_NAME).set(date.fromisoformat(target_date), services, source=_API_SOURCE)
  106. @mcp.tool()
  107. async def get_discount(target_date: str) -> dict | None:
  108. """Get discount for a date, or null if none set."""
  109. return await Discount(DEFAULT_CALENDAR_NAME).get(date.fromisoformat(target_date))
  110. @mcp.tool()
  111. async def get_discounts_range(start_date: str, end_date: str) -> dict:
  112. """Get discounts for each date in a range. Returns {date: {type, value} or null}."""
  113. start = date.fromisoformat(start_date)
  114. end = date.fromisoformat(end_date)
  115. events = await Discount(DEFAULT_CALENDAR_NAME).list(start, end)
  116. by_date: dict[str, dict | None] = {str(d): None for d in iter_dates(start, end)}
  117. for ev in events:
  118. d = ev['start'].date()
  119. if start <= d <= end:
  120. xd = safe_json_loads(ev['x_data'])
  121. if xd:
  122. by_date[str(d)] = {'type': xd.get('type'), 'value': xd.get('value')}
  123. return by_date
  124. @mcp.tool()
  125. async def set_discount(target_date: str, discount_type: str, value: int) -> None:
  126. """Set a discount. discount_type: 'percent' or 'flat'."""
  127. await Discount(DEFAULT_CALENDAR_NAME).set(
  128. date.fromisoformat(target_date), discount_type, value, source=_API_SOURCE
  129. )
  130. @mcp.tool()
  131. async def delete_discount(target_date: str) -> None:
  132. """Remove the discount on a date."""
  133. await Discount(DEFAULT_CALENDAR_NAME).delete_on(date.fromisoformat(target_date))
  134. @mcp.tool()
  135. async def refresh_credentials(service: str | None = None) -> dict:
  136. """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}}."""
  137. from room_cal.service_api._scripts import refresh_service
  138. from room_cal.service_api.types import ServiceAuthError
  139. keys = [service] if service else [s.key for s in _services()]
  140. loop = asyncio.get_running_loop()
  141. async def _do(key: str) -> tuple[str, str | None]:
  142. try:
  143. await loop.run_in_executor(None, refresh_service, key)
  144. return key, None
  145. except (ServiceAuthError, Exception) as e:
  146. return key, str(e)
  147. results = await asyncio.gather(*[_do(k) for k in keys])
  148. return {
  149. 'refreshed': [k for k, err in results if err is None],
  150. 'errors': {k: err for k, err in results if err is not None},
  151. }
  152. @mcp.tool()
  153. async def reload_caches() -> dict:
  154. """Clear all in-memory CalDAV event caches so the next request re-fetches from the server. Returns {cleared_calendars}."""
  155. from room_cal.store import clear_caches
  156. count = clear_caches()
  157. return {'cleared_calendars': count}
  158. @mcp.tool()
  159. async def get_chat_thread(service_key: str, chat_id: str) -> dict:
  160. """Fetch recent messages for a reservation thread. Returns {chat_id, messages: [{id, created_at, body, sender}], is_reply_needed?}."""
  161. from room_cal.service_api import ServiceAPI
  162. from room_cal.service_api.types import ServiceAuthError
  163. api = ServiceAPI()
  164. try:
  165. client = api.chat_client(service_key)
  166. except KeyError:
  167. raise ValueError(f'unknown service: {service_key!r}')
  168. except TypeError:
  169. raise ValueError(f'{service_key!r} does not support chat')
  170. try:
  171. thread = await client.get_thread(chat_id)
  172. except ServiceAuthError as e:
  173. raise RuntimeError(f'auth error: {e}')
  174. chat_id_out = getattr(thread, 'thread_id', None) or getattr(thread, 'reservation_id', None)
  175. result: dict = {
  176. 'chat_id': chat_id_out,
  177. 'messages': [
  178. {
  179. 'id': m.id,
  180. 'created_at': getattr(m, 'created_at_ms', None) or getattr(m, 'created_at', None),
  181. 'body': m.body,
  182. 'sender': getattr(m, 'sender_account_id', None) or getattr(m, 'sender', None),
  183. }
  184. for m in thread.messages
  185. ],
  186. }
  187. if hasattr(thread, 'is_reply_needed'):
  188. result['is_reply_needed'] = thread.is_reply_needed
  189. return result
  190. @mcp.tool()
  191. async def chat_send_ready(service_key: str) -> dict:
  192. """Check whether sending messages is currently available for a service. Returns {ready: bool}."""
  193. from room_cal.service_api import ServiceAPI
  194. api = ServiceAPI()
  195. try:
  196. client = api.chat_client(service_key)
  197. except KeyError:
  198. raise ValueError(f'unknown service: {service_key!r}')
  199. except TypeError:
  200. raise ValueError(f'{service_key!r} does not support chat')
  201. return {'ready': client.send_ready()}
  202. @mcp.tool()
  203. async def send_chat_message(service_key: str, chat_id: str, body: str) -> None:
  204. """Send a text message to a guest conversation thread."""
  205. from room_cal.service_api import ServiceAPI
  206. from room_cal.service_api.types import ServiceAuthError
  207. api = ServiceAPI()
  208. try:
  209. client = api.chat_client(service_key)
  210. except KeyError:
  211. raise ValueError(f'unknown service: {service_key!r}')
  212. except TypeError:
  213. raise ValueError(f'{service_key!r} does not support chat')
  214. try:
  215. await client.send_message(chat_id, body)
  216. except ServiceAuthError as e:
  217. raise RuntimeError(f'auth error: {e}')
  218. import importlib
  219. import pkgutil
  220. import room_cal.actions as _actions_pkg
  221. _ACTIONS: dict[str, tuple[str, str, list[str]]] = {}
  222. for _info in pkgutil.iter_modules(_actions_pkg.__path__):
  223. if _info.name.startswith('_'):
  224. continue
  225. _mod = importlib.import_module(f'room_cal.actions.{_info.name}')
  226. _spec = getattr(_mod, 'ACTION_SPEC', None)
  227. if _spec:
  228. _route_name, _allowed_keys = _spec
  229. _ACTIONS[_route_name] = (f'room_cal.actions.{_info.name}', _info.name, _allowed_keys)
  230. @mcp.tool()
  231. async def run_action(
  232. action: str,
  233. start_date: str,
  234. end_date: str | None = None,
  235. feed_name: str | None = None,
  236. title: str | None = None,
  237. service: str | None = None,
  238. weekday: int | None = None,
  239. weekend: int | None = None,
  240. ) -> object:
  241. """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)."""
  242. from datetime import date as _date
  243. if action not in _ACTIONS:
  244. raise ValueError(f'Unknown action: {action!r}')
  245. module_path, fn_name, allowed_keys = _ACTIONS[action]
  246. mod = importlib.import_module(module_path)
  247. fn = getattr(mod, fn_name)
  248. start = _date.fromisoformat(start_date)
  249. end = _date.fromisoformat(end_date) if end_date else start
  250. all_kwargs = {'feed_name': feed_name, 'title': title, 'service': service, 'weekday': weekday, 'weekend': weekend}
  251. kwargs = {k: v for k, v in all_kwargs.items() if k in allowed_keys and v is not None}
  252. return await fn(start, end, **kwargs)