guesty-mcp-server 0.3.0

package/src/server.js

@@ -0,0 +1,1096 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// Guesty API Configuration
+const GUESTY_CLIENT_ID = process.env.GUESTY_CLIENT_ID;
+const GUESTY_CLIENT_SECRET = process.env.GUESTY_CLIENT_SECRET;
+const GUESTY_API_BASE = "https://open-api.guesty.com/v1";
+
+if (!GUESTY_CLIENT_ID || !GUESTY_CLIENT_SECRET) {
+  console.error("Error: GUESTY_CLIENT_ID and GUESTY_CLIENT_SECRET environment variables are required.");
+  process.exit(1);
+}
+
+let cachedToken = null;
+let tokenExpiry = 0;
+
+async function getToken() {
+  if (cachedToken && Date.now() < tokenExpiry) return cachedToken;
+
+  const res = await fetch("https://open-api.guesty.com/oauth2/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "client_credentials",
+      scope: "open-api",
+      client_id: GUESTY_CLIENT_ID,
+      client_secret: GUESTY_CLIENT_SECRET,
+    }),
+  });
+
+  const data = await res.json();
+  if (!data.access_token) throw new Error(`Auth failed: ${JSON.stringify(data)}`);
+
+  cachedToken = data.access_token;
+  tokenExpiry = Date.now() + (data.expires_in - 60) * 1000;
+  return cachedToken;
+}
+
+async function guestyGet(path, params = {}, retries = 2) {
+  const token = await getToken();
+  const url = new URL(`${GUESTY_API_BASE}${path}`);
+  Object.entries(params).forEach(([k, v]) => {
+    if (v !== undefined && v !== null) url.searchParams.set(k, String(v));
+  });
+
+  const res = await fetch(url.toString(), {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+  });
+
+  if (res.status === 429 && retries > 0) {
+    const wait = Math.min(parseInt(res.headers.get("retry-after") || "5", 10), 30) * 1000;
+    await new Promise((r) => setTimeout(r, wait));
+    return guestyGet(path, params, retries - 1);
+  }
+
+  if (!res.ok) throw new Error(`Guesty API error ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+async function guestyPost(path, body, retries = 2) {
+  const token = await getToken();
+  const res = await fetch(`${GUESTY_API_BASE}${path}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (res.status === 429 && retries > 0) {
+    const wait = Math.min(parseInt(res.headers.get("retry-after") || "5", 10), 30) * 1000;
+    await new Promise((r) => setTimeout(r, wait));
+    return guestyPost(path, body, retries - 1);
+  }
+
+  if (!res.ok) throw new Error(`Guesty API error ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+async function guestyPut(path, body, retries = 2) {
+  const token = await getToken();
+  const res = await fetch(`${GUESTY_API_BASE}${path}`, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (res.status === 429 && retries > 0) {
+    const wait = Math.min(parseInt(res.headers.get("retry-after") || "5", 10), 30) * 1000;
+    await new Promise((r) => setTimeout(r, wait));
+    return guestyPut(path, body, retries - 1);
+  }
+
+  if (!res.ok) throw new Error(`Guesty API error ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+
+// Create MCP Server
+const server = new McpServer({
+  name: "guesty-mcp-server",
+  version: "0.3.0",
+});
+
+// Tool 1: Get Reservations
+server.tool(
+  "get_reservations",
+  "Fetch reservations from Guesty. Filter by date range, listing, status, or guest name.",
+  {
+    limit: z.number().optional().default(10).describe("Max results (default 10)"),
+    skip: z.number().optional().default(0).describe("Offset for pagination"),
+    checkInFrom: z.string().optional().describe("Check-in date from (YYYY-MM-DD)"),
+    checkInTo: z.string().optional().describe("Check-in date to (YYYY-MM-DD)"),
+    checkOutFrom: z.string().optional().describe("Check-out date from (YYYY-MM-DD)"),
+    checkOutTo: z.string().optional().describe("Check-out date to (YYYY-MM-DD)"),
+    listingId: z.string().optional().describe("Filter by listing ID"),
+    status: z.string().optional().describe("Filter by status: confirmed, canceled, inquiry, etc."),
+  },
+  async (params) => {
+    const queryParams = {
+      limit: params.limit,
+      skip: params.skip,
+      sort: "checkIn",
+      order: "desc",
+    };
+    if (params.checkInFrom) queryParams["checkIn[$gte]"] = params.checkInFrom;
+    if (params.checkInTo) queryParams["checkIn[$lte]"] = params.checkInTo;
+    if (params.checkOutFrom) queryParams["checkOut[$gte]"] = params.checkOutFrom;
+    if (params.checkOutTo) queryParams["checkOut[$lte]"] = params.checkOutTo;
+    if (params.listingId) queryParams.listingId = params.listingId;
+    if (params.status) queryParams.status = params.status;
+
+    const data = await guestyGet("/reservations", queryParams);
+
+    const results = data.results || [];
+    const summary = results.map((r) => ({
+      id: r._id,
+      guest: r.guest?.fullName || "Unknown",
+      guestEmail: r.guest?.email || "",
+      guestPhone: r.guest?.phone || "",
+      checkIn: r.checkIn?.slice(0, 10),
+      checkOut: r.checkOut?.slice(0, 10),
+      nights: r.nightsCount,
+      status: r.status,
+      source: r.source,
+      listing: r.listing?.title || "Unknown",
+      listingId: r.listingId,
+      totalPaid: r.money?.totalPaid,
+      currency: r.money?.currency,
+    }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ total: data.count, results: summary }, null, 2) }],
+    };
+  }
+);
+
+// Tool 2: Get Listing
+server.tool(
+  "get_listing",
+  "Fetch details about a specific property listing or all listings.",
+  {
+    listingId: z.string().optional().describe("Specific listing ID. Omit to get all listings."),
+    limit: z.number().optional().default(25).describe("Max results when fetching all"),
+  },
+  async (params) => {
+    let data;
+    if (params.listingId) {
+      data = await guestyGet(`/listings/${params.listingId}`);
+      const l = data;
+      const summary = {
+        id: l._id,
+        title: l.title,
+        nickname: l.nickname,
+        address: l.address?.full,
+        bedrooms: l.bedrooms,
+        bathrooms: l.bathrooms,
+        maxGuests: l.accommodates,
+        propertyType: l.propertyType,
+        prices: l.prices,
+        status: l.active ? "active" : "inactive",
+      };
+      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    } else {
+      data = await guestyGet("/listings", { limit: params.limit });
+      const listings = (data.results || []).map((l) => ({
+        id: l._id,
+        title: l.title,
+        nickname: l.nickname,
+        address: l.address?.full,
+        bedrooms: l.bedrooms,
+        bathrooms: l.bathrooms,
+        maxGuests: l.accommodates,
+        active: l.active,
+      }));
+      return { content: [{ type: "text", text: JSON.stringify({ total: data.count, listings }, null, 2) }] };
+    }
+  }
+);
+
+// Tool 3: Get Conversations
+server.tool(
+  "get_conversations",
+  "Fetch guest conversations/messages from Guesty. Get message history for a reservation or listing.",
+  {
+    reservationId: z.string().optional().describe("Filter by reservation ID"),
+    limit: z.number().optional().default(10).describe("Max conversations to return"),
+  },
+  async (params) => {
+    const queryParams = { limit: params.limit };
+    if (params.reservationId) queryParams["filters[reservationId]"] = params.reservationId;
+
+    const data = await guestyGet("/communication/conversations", queryParams);
+    const convos = (data.results || []).map((c) => ({
+      id: c._id,
+      guestName: c.guest?.fullName || "Unknown",
+      listing: c.listing?.title || "Unknown",
+      lastMessage: c.lastMessage?.body?.slice(0, 200) || "",
+      lastMessageAt: c.lastMessage?.sentAt,
+      unread: c.unreadCount,
+      reservationId: c.reservationId,
+    }));
+
+    return { content: [{ type: "text", text: JSON.stringify({ total: data.count, conversations: convos }, null, 2) }] };
+  }
+);
+
+// Tool 4: Send Guest Message
+server.tool(
+  "send_guest_message",
+  "Send a message to a guest in a Guesty conversation.",
+  {
+    conversationId: z.string().describe("The conversation ID to reply in"),
+    message: z.string().describe("The message text to send to the guest"),
+  },
+  async (params) => {
+    const data = await guestyPost(`/communication/conversations/${params.conversationId}/send-message`, {
+      body: params.message,
+    });
+    return { content: [{ type: "text", text: `Message sent successfully. ID: ${data._id || "OK"}` }] };
+  }
+);
+
+// Tool 5: Get Financials
+server.tool(
+  "get_financials",
+  "Fetch financial data including revenue, payouts, and reservation financials.",
+  {
+    listingId: z.string().optional().describe("Filter by listing ID"),
+    from: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().optional().describe("End date (YYYY-MM-DD)"),
+    limit: z.number().optional().default(25).describe("Max results"),
+  },
+  async (params) => {
+    // Pull reservations with financial data, sorted by most recent
+    const queryParams = {
+      limit: params.limit,
+      fields: "money guest checkIn checkOut listing status nightsCount",
+      sort: "checkIn",
+      order: "desc",
+    };
+    if (params.listingId) queryParams.listingId = params.listingId;
+    if (params.from) queryParams["checkIn[$gte]"] = params.from;
+    if (params.to) queryParams["checkIn[$lte]"] = params.to;
+
+    const data = await guestyGet("/reservations", queryParams);
+    const financials = (data.results || []).map((r) => ({
+      guest: r.guest?.fullName || "Unknown",
+      listing: r.listing?.title || "Unknown",
+      checkIn: r.checkIn?.slice(0, 10),
+      checkOut: r.checkOut?.slice(0, 10),
+      status: r.status,
+      totalPaid: r.money?.totalPaid,
+      hostPayout: r.money?.hostPayout,
+      commission: r.money?.commission,
+      currency: r.money?.currency,
+    }));
+
+    const totalRevenue = financials.reduce((sum, r) => sum + (r.totalPaid || 0), 0);
+    const totalPayout = financials.reduce((sum, r) => sum + (r.hostPayout || 0), 0);
+
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          summary: { totalRevenue, totalPayout, reservationCount: financials.length },
+          reservations: financials,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// Tool 6: Update Pricing
+server.tool(
+  "update_pricing",
+  "Update the base price for a listing on specific dates or the default base price.",
+  {
+    listingId: z.string().describe("The listing ID to update pricing for"),
+    basePrice: z.number().optional().describe("New default base price per night"),
+    dateFrom: z.string().optional().describe("Start date for date-specific pricing (YYYY-MM-DD)"),
+    dateTo: z.string().optional().describe("End date for date-specific pricing (YYYY-MM-DD)"),
+    price: z.number().optional().describe("Price per night for the date range"),
+  },
+  async (params) => {
+    if (params.basePrice) {
+      const data = await guestyPut(`/listings/${params.listingId}`, {
+        prices: { basePrice: params.basePrice },
+      });
+      return { content: [{ type: "text", text: `Base price updated to $${params.basePrice} for listing ${params.listingId}` }] };
+    }
+
+    if (params.dateFrom && params.dateTo && params.price) {
+      const data = await guestyPut(`/listings/${params.listingId}/calendar`, {
+        dateFrom: params.dateFrom,
+        dateTo: params.dateTo,
+        price: params.price,
+      });
+      return { content: [{ type: "text", text: `Price set to $${params.price}/night from ${params.dateFrom} to ${params.dateTo}` }] };
+    }
+
+    return { content: [{ type: "text", text: "Error: Provide either basePrice or dateFrom+dateTo+price" }] };
+  }
+);
+
+// ============ V2 TOOLS ============
+
+// Tool 7: Create Reservation (Direct Booking)
+server.tool(
+  "create_reservation",
+  "Create a new reservation/booking in Guesty. Use for direct bookings from your website.",
+  {
+    listingId: z.string().describe("The listing ID to book"),
+    checkIn: z.string().describe("Check-in date (YYYY-MM-DD)"),
+    checkOut: z.string().describe("Check-out date (YYYY-MM-DD)"),
+    guestName: z.string().describe("Guest full name"),
+    guestEmail: z.string().optional().describe("Guest email address"),
+    guestPhone: z.string().optional().describe("Guest phone number"),
+    numberOfGuests: z.number().optional().default(1).describe("Number of guests"),
+    source: z.string().optional().default("direct").describe("Booking source (direct, website, etc.)"),
+  },
+  async (params) => {
+    const body = {
+      listingId: params.listingId,
+      checkInDateLocalized: params.checkIn,
+      checkOutDateLocalized: params.checkOut,
+      status: "confirmed",
+      guest: {
+        fullName: params.guestName,
+        email: params.guestEmail,
+        phone: params.guestPhone,
+      },
+      guestsCount: params.numberOfGuests,
+      source: params.source,
+    };
+
+    const data = await guestyPost("/reservations", body);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          reservationId: data._id,
+          confirmationCode: data.confirmationCode,
+          guest: params.guestName,
+          listing: params.listingId,
+          dates: `${params.checkIn} → ${params.checkOut}`,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// Tool 8: Get Reviews
+server.tool(
+  "get_reviews",
+  "Fetch guest reviews for your properties from all channels.",
+  {
+    listingId: z.string().optional().describe("Filter by listing ID"),
+    limit: z.number().optional().default(10).describe("Max results"),
+  },
+  async (params) => {
+    const queryParams = { limit: params.limit };
+    if (params.listingId) queryParams.listingId = params.listingId;
+
+    const data = await guestyGet("/reviews", queryParams);
+    const reviews = (data.results || []).map((r) => ({
+      id: r._id,
+      listing: r.listing?.title || "Unknown",
+      guestName: r.guest?.fullName || "Unknown",
+      rating: r.rating,
+      comment: r.comment?.slice(0, 300),
+      response: r.response?.slice(0, 200),
+      channel: r.source,
+      date: r.createdAt?.slice(0, 10),
+    }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ total: data.count, reviews }, null, 2) }],
+    };
+  }
+);
+
+// Tool 9: Get Calendar
+server.tool(
+  "get_calendar",
+  "Fetch calendar availability and pricing for a listing over a date range.",
+  {
+    listingId: z.string().describe("The listing ID"),
+    from: z.string().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().describe("End date (YYYY-MM-DD)"),
+  },
+  async (params) => {
+    const data = await guestyGet(`/listings/${params.listingId}/calendar`, {
+      from: params.from,
+      to: params.to,
+    });
+
+    const days = (data.days || data || []).map ? (data.days || []).map((d) => ({
+      date: d.date,
+      available: d.status === "available",
+      price: d.price,
+      minNights: d.minNights,
+      blockReason: d.blockReason,
+    })) : [];
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ listing: params.listingId, days }, null, 2) }],
+    };
+  }
+);
+
+// Tool 10: Update Calendar
+server.tool(
+  "update_calendar",
+  "Block or unblock dates, set minimum nights, or update availability for a listing.",
+  {
+    listingId: z.string().describe("The listing ID"),
+    dateFrom: z.string().describe("Start date (YYYY-MM-DD)"),
+    dateTo: z.string().describe("End date (YYYY-MM-DD)"),
+    status: z.string().optional().describe("Set to 'available' or 'unavailable'"),
+    minNights: z.number().optional().describe("Minimum night stay"),
+    blockReason: z.string().optional().describe("Reason for blocking: owner, maintenance, other"),
+  },
+  async (params) => {
+    const body = {};
+    if (params.status) body.status = params.status;
+    if (params.minNights) body.minNights = params.minNights;
+    if (params.blockReason) body.note = params.blockReason;
+
+    const data = await guestyPut(`/listings/${params.listingId}/calendar`, {
+      dateFrom: params.dateFrom,
+      dateTo: params.dateTo,
+      ...body,
+    });
+
+    return {
+      content: [{ type: "text", text: `Calendar updated for ${params.listingId}: ${params.dateFrom} to ${params.dateTo}` }],
+    };
+  }
+);
+
+// Tool 11: Respond to Review
+server.tool(
+  "respond_to_review",
+  "Post a response to a guest review.",
+  {
+    reviewId: z.string().describe("The review ID to respond to"),
+    response: z.string().describe("Your response text"),
+  },
+  async (params) => {
+    const data = await guestyPut(`/reviews/${params.reviewId}`, {
+      response: params.response,
+    });
+    return { content: [{ type: "text", text: `Review response posted successfully for review ${params.reviewId}` }] };
+  }
+);
+
+// Tool 12: Get Owner Statements
+server.tool(
+  "get_owner_statements",
+  "Fetch owner revenue statements/reports for properties.",
+  {
+    listingId: z.string().optional().describe("Filter by listing ID"),
+    from: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().optional().describe("End date (YYYY-MM-DD)"),
+    limit: z.number().optional().default(10).describe("Max results"),
+  },
+  async (params) => {
+    const queryParams = { limit: params.limit };
+    if (params.listingId) queryParams.listingId = params.listingId;
+    if (params.from) queryParams["from"] = params.from;
+    if (params.to) queryParams["to"] = params.to;
+
+    // Owner statements not available via Open API v1 — fall back to financial data from reservations
+    const resData = await guestyGet("/reservations", {
+      limit: params.limit,
+      fields: "money guest checkIn checkOut listing status nightsCount",
+      ...(params.listingId && { listingId: params.listingId }),
+      ...(params.from && { "checkIn[$gte]": params.from }),
+      ...(params.to && { "checkIn[$lte]": params.to }),
+    });
+    const results = (resData.results || []).map((r) => ({
+      guest: r.guest?.fullName || "Unknown",
+      listing: r.listing?.title || "Unknown",
+      checkIn: r.checkIn?.slice(0, 10),
+      checkOut: r.checkOut?.slice(0, 10),
+      status: r.status,
+      totalPaid: r.money?.totalPaid,
+      hostPayout: r.money?.hostPayout,
+      commission: r.money?.commission,
+      currency: r.money?.currency,
+    }));
+    const totalRevenue = results.reduce((sum, r) => sum + (r.totalPaid || 0), 0);
+    const totalPayout = results.reduce((sum, r) => sum + (r.hostPayout || 0), 0);
+    return {
+      content: [{ type: "text", text: JSON.stringify({ summary: { totalRevenue, totalPayout, count: results.length }, results }, null, 2) }],
+    };
+  }
+);
+
+// Tool 13: Get Expenses
+server.tool(
+  "get_expenses",
+  "Fetch operational expenses tracked in Guesty.",
+  {
+    listingId: z.string().optional().describe("Filter by listing ID"),
+    from: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().optional().describe("End date (YYYY-MM-DD)"),
+    limit: z.number().optional().default(25).describe("Max results"),
+  },
+  async (params) => {
+    const queryParams = { limit: params.limit };
+    if (params.listingId) queryParams.listingId = params.listingId;
+    if (params.from) queryParams["from"] = params.from;
+    if (params.to) queryParams["to"] = params.to;
+
+    // Expenses endpoint may not be available on all Guesty plans
+    let data;
+    try {
+      data = await guestyGet("/expenses", queryParams);
+    } catch (e) {
+      // Fall back to listing expenses if main endpoint not available
+      return { content: [{ type: "text", text: JSON.stringify({ note: "Expenses endpoint not available on your Guesty plan. Use get_financials for reservation-based financial data." }, null, 2) }] };
+    }
+    const expenses = (data.results || []).map((e) => ({
+      id: e._id,
+      title: e.title,
+      amount: e.amount,
+      currency: e.currency,
+      category: e.category,
+      listing: e.listing?.title || "Unknown",
+      date: e.date?.slice(0, 10),
+      vendor: e.vendor,
+    }));
+
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({ total: data.count, expenses }, null, 2),
+      }],
+    };
+  }
+);
+
+// Tool 14: Get Channels (Connected OTAs)
+server.tool(
+  "get_channels",
+  "List connected booking channels (Airbnb, VRBO, Booking.com, etc.) and their status.",
+  {
+    listingId: z.string().optional().describe("Filter by listing ID to see which channels a property is on"),
+  },
+  async (params) => {
+    if (params.listingId) {
+      const listing = await guestyGet(`/listings/${params.listingId}`);
+      const channels = (listing.integrations || []).map((i) => ({
+        channel: i.platform,
+        externalId: i.externalId,
+        externalUrl: i.externalUrl,
+        status: i.status,
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify({ listing: listing.title, channels }, null, 2) }],
+      };
+    }
+    // Get all listings with their channel info
+    const data = await guestyGet("/listings", { limit: 50 });
+    const listings = (data.results || []).map((l) => ({
+      id: l._id,
+      title: l.title,
+      nickname: l.nickname,
+      channels: (l.integrations || []).map((i) => i.platform).join(", ") || "none",
+      active: l.active,
+    }));
+    return {
+      content: [{ type: "text", text: JSON.stringify({ total: data.count, listings }, null, 2) }],
+    };
+  }
+);
+
+// Tool 15: Get Tasks (Cleaning/Maintenance)
+server.tool(
+  "get_tasks",
+  "Fetch cleaning and maintenance tasks from Guesty.",
+  {
+    listingId: z.string().optional().describe("Filter by listing ID"),
+    status: z.string().optional().describe("Filter by status: pending, confirmed, completed, canceled"),
+    limit: z.number().optional().default(25).describe("Max results (minimum 25 per Guesty API)"),
+  },
+  async (params) => {
+    const queryParams = {
+      limit: Math.max(params.limit, 25),
+      columns: "id,status,type,listingId,scheduledFor,assignee,description",
+    };
+    if (params.listingId) queryParams.listingId = params.listingId;
+    if (params.status) queryParams.status = params.status;
+
+    const data = await guestyGet("/tasks-open-api/tasks", queryParams);
+    const tasks = (data.data || data.results || []).map((t) => ({
+      id: t._id || t.id,
+      type: t.type,
+      status: t.status,
+      listingId: t.listingId,
+      assignee: t.assignee?.fullName || t.assignee || "Unassigned",
+      scheduledFor: t.scheduledFor?.slice?.(0, 10) || t.scheduledFor,
+      description: t.description?.slice?.(0, 200) || t.description,
+    }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ total: data.count || tasks.length, tasks }, null, 2) }],
+    };
+  }
+);
+
+// ============ V3 TOOLS ============
+
+// Tool 16: Get Photos
+server.tool(
+  "get_photos",
+  "Fetch photos for a specific listing including URLs, captions, and sort order.",
+  {
+    listingId: z.string().describe("The listing ID to get photos for"),
+  },
+  async (params) => {
+    const data = await guestyGet(`/listings/${params.listingId}`);
+    const photos = (data.pictures || []).map((p) => ({
+      url: p.original || p.thumbnail,
+      caption: p.caption || "",
+      sortOrder: p.sortOrder,
+    }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ listing: params.listingId, photoCount: photos.length, photos }, null, 2) }],
+    };
+  }
+);
+
+// Tool 17: Update Photos
+server.tool(
+  "update_photos",
+  "Replace or reorder photos for a listing. Provide the full array of photos in desired order.",
+  {
+    listingId: z.string().describe("The listing ID to update photos for"),
+    photos: z.array(z.object({
+      url: z.string().describe("Photo URL"),
+      caption: z.string().optional().describe("Photo caption"),
+    })).describe("Array of photo objects with url and optional caption"),
+  },
+  async (params) => {
+    const data = await guestyPut(`/listings/${params.listingId}`, {
+      pictures: params.photos,
+    });
+    return { content: [{ type: "text", text: `Photos updated for listing ${params.listingId}. ${params.photos.length} photos set.` }] };
+  }
+);
+
+// Tool 18: Get Calendar Blocks
+server.tool(
+  "get_calendar_blocks",
+  "Get blocked dates and their reasons for a listing over a date range.",
+  {
+    listingId: z.string().describe("The listing ID"),
+    from: z.string().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().describe("End date (YYYY-MM-DD)"),
+  },
+  async (params) => {
+    const data = await guestyGet(`/listings/${params.listingId}/calendar`, {
+      from: params.from,
+      to: params.to,
+    });
+
+    const blockedDays = (data.days || [])
+      .filter((d) => d.status !== "available")
+      .map((d) => ({
+        date: d.date,
+        blockReason: d.blockReason || d.note || "unknown",
+        status: d.status,
+      }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ listing: params.listingId, blockedCount: blockedDays.length, blockedDays }, null, 2) }],
+    };
+  }
+);
+
+// Tool 19: Create Expense
+server.tool(
+  "create_expense",
+  "Create a new expense record for a listing in Guesty.",
+  {
+    listingId: z.string().describe("The listing ID the expense is for"),
+    title: z.string().describe("Expense title/description"),
+    amount: z.number().describe("Expense amount"),
+    currency: z.string().optional().default("USD").describe("Currency code (default USD)"),
+    category: z.string().optional().describe("Expense category (e.g., cleaning, maintenance, supplies)"),
+    vendor: z.string().optional().describe("Vendor/supplier name"),
+    date: z.string().optional().describe("Expense date (YYYY-MM-DD)"),
+  },
+  async (params) => {
+    const body = {
+      listingId: params.listingId,
+      title: params.title,
+      amount: params.amount,
+      currency: params.currency,
+    };
+    if (params.category) body.category = params.category;
+    if (params.vendor) body.vendor = params.vendor;
+    if (params.date) body.date = params.date;
+
+    const data = await guestyPost("/expenses", body);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          expenseId: data._id,
+          title: params.title,
+          amount: `${params.currency} ${params.amount}`,
+          listing: params.listingId,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// Tool 20: Get Guests
+server.tool(
+  "get_guests",
+  "Fetch guest database/profiles. Search by name or email.",
+  {
+    limit: z.number().optional().default(10).describe("Max results (default 10)"),
+    skip: z.number().optional().describe("Offset for pagination"),
+    query: z.string().optional().describe("Search by guest name or email"),
+  },
+  async (params) => {
+    const queryParams = { limit: params.limit };
+    if (params.skip) queryParams.skip = params.skip;
+    if (params.query) queryParams.q = params.query;
+
+    const data = await guestyGet("/guests", queryParams);
+    const guests = (data.results || []).map((g) => ({
+      id: g._id,
+      fullName: g.fullName,
+      email: g.email,
+      phone: g.phone,
+      reservationCount: g.reservationsCount,
+      createdAt: g.createdAt?.slice(0, 10),
+    }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ total: data.count, guests }, null, 2) }],
+    };
+  }
+);
+
+// Tool 21: Get Guest by ID
+server.tool(
+  "get_guest_by_id",
+  "Get detailed guest profile by guest ID.",
+  {
+    guestId: z.string().describe("The guest ID"),
+  },
+  async (params) => {
+    const data = await guestyGet(`/guests/${params.guestId}`);
+    const guest = {
+      id: data._id,
+      fullName: data.fullName,
+      firstName: data.firstName,
+      lastName: data.lastName,
+      email: data.email,
+      phone: data.phone,
+      address: data.address,
+      reservationsCount: data.reservationsCount,
+      notes: data.notes,
+      tags: data.tags,
+      createdAt: data.createdAt?.slice(0, 10),
+    };
+
+    return {
+      content: [{ type: "text", text: JSON.stringify(guest, null, 2) }],
+    };
+  }
+);
+
+// Tool 22: Update Listing
+server.tool(
+  "update_listing",
+  "Update listing details such as title, description, amenities, min nights, and max guests.",
+  {
+    listingId: z.string().describe("The listing ID to update"),
+    title: z.string().optional().describe("New listing title"),
+    publicDescription: z.string().optional().describe("Public-facing description"),
+    privateDescription: z.string().optional().describe("Private/internal description"),
+    amenities: z.array(z.string()).optional().describe("Array of amenity strings"),
+    minNights: z.number().optional().describe("Minimum night stay"),
+    maxGuests: z.number().optional().describe("Maximum number of guests"),
+  },
+  async (params) => {
+    const body = {};
+    if (params.title) body.title = params.title;
+    if (params.publicDescription) body.publicDescription = { summary: params.publicDescription };
+    if (params.privateDescription) body.privateDescription = params.privateDescription;
+    if (params.amenities) body.amenities = params.amenities;
+    if (params.minNights) body.minNights = params.minNights;
+    if (params.maxGuests) body.accommodates = params.maxGuests;
+
+    const data = await guestyPut(`/listings/${params.listingId}`, body);
+    const updated = Object.keys(body).join(", ");
+    return { content: [{ type: "text", text: `Listing ${params.listingId} updated. Fields changed: ${updated}` }] };
+  }
+);
+
+// Tool 23: Get Automation Rules
+server.tool(
+  "get_automation_rules",
+  "List automation and workflow rules configured in Guesty.",
+  {
+    limit: z.number().optional().default(25).describe("Max results (default 25)"),
+  },
+  async (params) => {
+    // Automations endpoint may not be available on Open API v1
+    try {
+      const data = await guestyGet("/automations", { limit: params.limit });
+      const automations = (data.results || []).map((a) => ({
+        id: a._id,
+        title: a.title,
+        active: a.active,
+        trigger: a.trigger,
+        createdAt: a.createdAt?.slice(0, 10),
+      }));
+      return { content: [{ type: "text", text: JSON.stringify({ total: data.count, automations }, null, 2) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: JSON.stringify({ note: "Automations endpoint not available on your Guesty plan or API version. Check Guesty dashboard for automation rules." }, null, 2) }] };
+    }
+  }
+);
+
+// Tool 24: Create Task
+server.tool(
+  "create_task",
+  "Create a cleaning or maintenance task for a listing.",
+  {
+    listingId: z.string().describe("The listing ID the task is for"),
+    type: z.string().describe("Task type: cleaning or maintenance"),
+    scheduledFor: z.string().describe("Scheduled date (YYYY-MM-DD)"),
+    assigneeId: z.string().optional().describe("Assignee user ID"),
+    description: z.string().optional().describe("Task description/notes"),
+  },
+  async (params) => {
+    const body = {
+      listingId: params.listingId,
+      type: params.type,
+      scheduledFor: params.scheduledFor,
+    };
+    if (params.assigneeId) body.assigneeId = params.assigneeId;
+    if (params.description) body.description = params.description;
+
+    const data = await guestyPost("/tasks-open-api/tasks", body);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          taskId: data._id,
+          type: params.type,
+          listing: params.listingId,
+          scheduledFor: params.scheduledFor,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// Tool 25: Update Reservation
+server.tool(
+  "update_reservation",
+  "Update reservation details such as status, dates, guest info, or add notes.",
+  {
+    reservationId: z.string().describe("The reservation ID to update"),
+    status: z.string().optional().describe("New status: confirmed, canceled, inquiry, etc."),
+    checkIn: z.string().optional().describe("New check-in date (YYYY-MM-DD)"),
+    checkOut: z.string().optional().describe("New check-out date (YYYY-MM-DD)"),
+    guestName: z.string().optional().describe("Updated guest full name"),
+    guestEmail: z.string().optional().describe("Updated guest email"),
+    note: z.string().optional().describe("Add a note to the reservation"),
+  },
+  async (params) => {
+    const body = {};
+    if (params.status) body.status = params.status;
+    if (params.checkIn) body.checkInDateLocalized = params.checkIn;
+    if (params.checkOut) body.checkOutDateLocalized = params.checkOut;
+    if (params.guestName || params.guestEmail) {
+      body.guest = {};
+      if (params.guestName) body.guest.fullName = params.guestName;
+      if (params.guestEmail) body.guest.email = params.guestEmail;
+    }
+    if (params.note) body.note = params.note;
+
+    const data = await guestyPut(`/reservations/${params.reservationId}`, body);
+    const updated = Object.keys(body).join(", ");
+    return { content: [{ type: "text", text: `Reservation ${params.reservationId} updated. Fields changed: ${updated}` }] };
+  }
+);
+
+// Tool 26: Get Supported Languages
+server.tool(
+  "get_supported_languages",
+  "Get supported languages configured for a listing.",
+  {
+    listingId: z.string().describe("The listing ID"),
+  },
+  async (params) => {
+    // Try supported-languages endpoint, fall back to listing data
+    let data;
+    try {
+      data = await guestyGet(`/listings/${params.listingId}/supported-languages`);
+    } catch (e) {
+      // Fall back to extracting language info from listing
+      const listing = await guestyGet(`/listings/${params.listingId}`);
+      data = { languages: listing.languages || listing.supportedLanguages || [], note: "Extracted from listing data" };
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify({ listing: params.listingId, languages: data }, null, 2) }],
+    };
+  }
+);
+
+// Tool 27: Search Reservations
+server.tool(
+  "search_reservations",
+  "Search reservations by guest name, email, or confirmation code.",
+  {
+    query: z.string().describe("Search query — guest name, email, or confirmation code"),
+    limit: z.number().optional().default(10).describe("Max results (default 10)"),
+  },
+  async (params) => {
+    const data = await guestyGet("/reservations", {
+      limit: params.limit,
+      q: params.query,
+      sort: "checkIn",
+      order: "desc",
+    });
+
+    const results = (data.results || []).map((r) => ({
+      id: r._id,
+      confirmationCode: r.confirmationCode,
+      guest: r.guest?.fullName || "Unknown",
+      guestEmail: r.guest?.email || "",
+      checkIn: r.checkIn?.slice(0, 10),
+      checkOut: r.checkOut?.slice(0, 10),
+      status: r.status,
+      listing: r.listing?.title || "Unknown",
+      listingId: r.listingId,
+      totalPaid: r.money?.totalPaid,
+    }));
+
+    return {
+      content: [{ type: "text", text: JSON.stringify({ total: data.count, results }, null, 2) }],
+    };
+  }
+);
+
+// Tool 28: Get Listing Occupancy
+server.tool(
+  "get_listing_occupancy",
+  "Calculate occupancy rate for a listing over a date range.",
+  {
+    listingId: z.string().describe("The listing ID"),
+    from: z.string().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().describe("End date (YYYY-MM-DD)"),
+  },
+  async (params) => {
+    const data = await guestyGet(`/listings/${params.listingId}/calendar`, {
+      from: params.from,
+      to: params.to,
+    });
+
+    const days = data.days || [];
+    const totalDays = days.length;
+    let bookedDays = 0;
+    let blockedDays = 0;
+    let availableDays = 0;
+
+    days.forEach((d) => {
+      if (d.status === "booked" || d.status === "reserved") bookedDays++;
+      else if (d.status === "unavailable" || d.status === "blocked") blockedDays++;
+      else availableDays++;
+    });
+
+    const occupancyRate = totalDays > 0 ? Math.round((bookedDays / totalDays) * 10000) / 100 : 0;
+
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          listing: params.listingId,
+          from: params.from,
+          to: params.to,
+          totalDays,
+          bookedDays,
+          blockedDays,
+          availableDays,
+          occupancyRate: `${occupancyRate}%`,
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// Tool 29: Get Revenue Summary
+server.tool(
+  "get_revenue_summary",
+  "Get aggregated revenue summary across all or specific listings for a date range.",
+  {
+    from: z.string().optional().describe("Start date (YYYY-MM-DD)"),
+    to: z.string().optional().describe("End date (YYYY-MM-DD)"),
+    listingId: z.string().optional().describe("Filter by listing ID"),
+  },
+  async (params) => {
+    const queryParams = {
+      limit: 100,
+      fields: "money nightsCount listing checkIn checkOut status",
+      sort: "checkIn",
+      order: "desc",
+      status: "confirmed",
+    };
+    if (params.listingId) queryParams.listingId = params.listingId;
+    if (params.from) queryParams["checkIn[$gte]"] = params.from;
+    if (params.to) queryParams["checkIn[$lte]"] = params.to;
+
+    const data = await guestyGet("/reservations", queryParams);
+    const reservations = data.results || [];
+
+    let totalRevenue = 0;
+    let totalPayout = 0;
+    let totalNights = 0;
+
+    reservations.forEach((r) => {
+      totalRevenue += r.money?.totalPaid || 0;
+      totalPayout += r.money?.hostPayout || 0;
+      totalNights += r.nightsCount || 0;
+    });
+
+    const reservationCount = reservations.length;
+    const averageNightlyRate = totalNights > 0 ? Math.round((totalRevenue / totalNights) * 100) / 100 : 0;
+
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          totalRevenue,
+          totalPayout,
+          averageNightlyRate,
+          totalNights,
+          reservationCount,
+          period: {
+            from: params.from || "all-time",
+            to: params.to || "present",
+          },
+          listingId: params.listingId || "all",
+        }, null, 2),
+      }],
+    };
+  }
+);
+
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);