guesty-mcp-server 0.8.2 → 0.9.2

package/src/license.js.pre-v092-stub-20260521-1751

@@ -0,0 +1,163 @@
+/**
+ * Guesty MCP Server — License Key System (v2)
+ * 
+ * 3-Layer Monetization Model (Danny-approved 2026-04-06):
+ * - Layer 1: MCP Server = operations/data tool (FREE, lead gen)
+ * - Layer 2: Guesty Copilot = SaaS platform (PAID)
+ * - Layer 3: DLJ Managed AI = premium service (our real IP)
+ * 
+ * FREE tier: Read-only operations data — reservations, listings, calendar,
+ *   financials, tasks, guest lookup, pricing, occupancy, channels, photos.
+ * PRO+ tier: Guest communication — messaging, review responses, webhook
+ *   creation, reservation writes, listing updates.
+ * 
+ * Reads GUESTY_MCP_LICENSE_KEY from env.
+ * No key or invalid key = free tier (operations data only).
+ */
+
+// Free tier: read-only operations and data tools
+const FREE_TOOLS = [
+  // Reservations (read-only)
+  "get_reservations",
+  "search_reservations",
+  "get_reservation_financials",
+  // Listings (read-only)
+  "get_listing",
+  "get_listing_occupancy",
+  "get_listing_pricing",
+  "get_photos",
+  // Guests (read-only)
+  "get_guests",
+  "get_guest_by_id",
+  // Calendar (read-only)
+  "get_calendar",
+  "get_calendar_blocks",
+  // Financials (read-only)
+  "get_financials",
+  "get_owner_statements",
+  "get_expenses",
+  "get_revenue_summary",
+  // Operations (read-only)
+  "get_tasks",
+  "get_channels",
+  "get_automation_rules",
+  "get_custom_fields",
+  "get_account_info",
+  "get_supported_languages",
+  // Reviews (read-only)
+  "get_reviews",
+  // Webhooks (read-only)
+  "get_webhooks",
+];
+
+// Enterprise tier: IoT + property aggregator tools (4 total)
+// These ship in active validation per data-integrity gate; require Enterprise license.
+const ENT_TOOLS = [
+  "get_readiness_score",
+  "get_property_health",
+  "submit_checkout_photos",
+  "get_maintenance_alerts",
+];
+
+// Business tier: operational/SLA features the binary advertises (consumed by getTierInfo).
+// No per-call tool gating — Business unlocks the same 39 base tools as Pro plus the
+// multi-account license terms and priority support promised by guestycopilot.com pricing.
+const BIZ_FEATURES = {
+  multiAccountLicense: true,
+  prioritySupport: true,
+};
+
+// PRO+ gated tools: guest communication, writes, and real-time events
+// send_guest_message, respond_to_review, create_webhook, delete_webhook,
+// create_reservation, update_reservation, create_reservation_note,
+// update_pricing, update_calendar, update_listing, update_photos,
+// update_listing_pricing, create_expense, create_task,
+// get_conversations (contains message content)
+
+// Simple key-to-tier mapping
+// Production: Stripe webhook or DB lookup
+// For now: keys prefixed gmcp_pro_*, gmcp_biz_*, gmcp_ent_*
+function resolveTier(licenseKey) {
+  if (!licenseKey) return "free";
+  const key = licenseKey.trim();
+  if (key.startsWith("gmcp_ent_")) return "enterprise";
+  if (key.startsWith("gmcp_biz_")) return "business";
+  if (key.startsWith("gmcp_pro_")) return "pro";
+  if (key === "test_pro") return "pro";
+  if (key === "test_biz") return "business";
+  if (key === "test_ent") return "enterprise";
+  return "free";
+}
+
+function getTier() {
+  return resolveTier(process.env.GUESTY_MCP_LICENSE_KEY);
+}
+
+function isToolAllowed(toolName) {
+  const tier = getTier();
+  if (tier === "free") {
+    return FREE_TOOLS.includes(toolName);
+  }
+  // Enterprise-tier tools require enterprise license
+  if (ENT_TOOLS.includes(toolName)) {
+    return tier === "enterprise";
+  }
+  // All other paid tools (Pro+) allowed for pro / business / enterprise
+  return true;
+}
+
+function getTierInfo() {
+  const tier = getTier();
+  // 39 Guesty core tools + 1 IoT (get_readiness_score) + 3 Enterprise aggregators
+  // (get_property_health, submit_checkout_photos, get_maintenance_alerts) = 43.
+  // Updated 2026-04-17 for Enterprise Tier MVP merge (Owner msg 6406).
+  const totalTools = 43;
+  const entToolCount = ENT_TOOLS.length;
+  const baseToolCount = totalTools - entToolCount;  // 39
+  const accessibleCount =
+    tier === "free" ? FREE_TOOLS.length :
+    tier === "enterprise" ? totalTools :
+    baseToolCount;  // pro / business
+  return {
+    tier,
+    hasKey: !!process.env.GUESTY_MCP_LICENSE_KEY,
+    freeToolCount: FREE_TOOLS.length,
+    baseToolCount,
+    entToolCount,
+    accessibleToolCount: accessibleCount,
+    gatedToolCount: totalTools - accessibleCount,
+    unlocked: tier !== "free",
+    bizFeatures: tier === "business" || tier === "enterprise" ? BIZ_FEATURES : null,
+  };
+}
+
+function gatedHandler(toolName, handler) {
+  return async (params) => {
+    if (!isToolAllowed(toolName)) {
+      const tier = getTier();
+      let msg;
+      if (tier === "free") {
+        msg = "This tool (" + toolName + ") requires a Pro or higher license. " +
+              "Free tier includes " + FREE_TOOLS.length + " operations and data tools. " +
+              "Guest messaging, review responses, and write operations require Pro+. " +
+              "Upgrade at https://guestycopilot.com/pricing -- " +
+              "Set GUESTY_MCP_LICENSE_KEY env var to unlock all 43 tools.";
+      } else if (ENT_TOOLS.includes(toolName)) {
+        msg = "This tool (" + toolName + ") requires an Enterprise license. " +
+              "Your current tier (" + tier + ") includes the 39 base Guesty tools. " +
+              "Enterprise adds IoT readiness, property health, checkout photo intake, " +
+              "and maintenance alerts (4 additional tools). " +
+              "Talk to us at https://guestycopilot.com/pricing";
+      } else {
+        msg = "This tool (" + toolName + ") is not available in your current tier (" + tier + ").";
+      }
+      return {
+        content: [{ type: "text", text: msg }],
+        isError: true,
+      };
+    }
+    return handler(params);
+  };
+}
+
+export { getTier, isToolAllowed, getTierInfo, gatedHandler, FREE_TOOLS, ENT_TOOLS, BIZ_FEATURES };

package/src/resources.js

@@ -0,0 +1,273 @@
+// src/resources.js
+//
+// MCP Resources primitive for Guesty MCP Server — v0.9.0 (2026-04-20).
+//
+// Exposes read-only addressable resources via guesty:// URI scheme so clients
+// can surface Guesty entities as @-mentionable context rather than forcing a
+// tool call for every read. Reuses the existing `guestyGet` helper from server.js.
+//
+// URI templates registered:
+//   guesty://listing/{id}               — listing detail
+//   guesty://reservation/{id}           — reservation detail
+//   guesty://review/{id}                — review detail
+//   guesty://guest/{id}                 — guest profile
+//   guesty://thread/{conversation_id}   — message thread
+//   guesty://report/revenue/{month}     — monthly revenue snapshot (YYYY-MM)
+//   guesty://listing/{listing_id}/tasks — open tasks for a listing
+//
+// Capabilities declared by McpServer when at least one resource is registered:
+//   resources: { listChanged: false, subscribe: false }
+//
+// Subscribe + listChanged are intentionally OFF for v0.9.0 — keeps scope tight.
+// Enable in v0.10.0 after per-resource caching strategy lands.
+
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+/**
+ * @param {object} server  - McpServer instance
+ * @param {object} deps    - { guestyGet }  dependency injection to avoid circular imports
+ */
+export function registerResources(server, { guestyGet }) {
+  // --- Helper: shape a ReadResourceResult ---
+  const asJsonResource = (uri, data, mimeType = "application/json") => ({
+    contents: [
+      {
+        uri: uri.toString(),
+        mimeType,
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2),
+      },
+    ],
+  });
+
+  const asErrorResource = (uri, err) => ({
+    contents: [
+      {
+        uri: uri.toString(),
+        mimeType: "text/plain",
+        text: `Error reading ${uri}: ${err.message || String(err)}`,
+      },
+    ],
+  });
+
+  // --- Helper: list callback factory ---
+  // For each template we provide a list callback that returns the top N of that
+  // entity so clients can enumerate them for @-mention pickers. Required per SDK.
+  const listTopN = async (path, buildUri, limit = 25) => {
+    try {
+      const data = await guestyGet(path, { limit });
+      const items = data.results || [];
+      return {
+        resources: items.map((item) => ({
+          uri: buildUri(item),
+          name: item.title || item.guest?.fullName || item.name || item._id,
+          description: item.nickname || item.publicReview || undefined,
+          mimeType: "application/json",
+        })),
+      };
+    } catch (e) {
+      return { resources: [] };
+    }
+  };
+
+  // --- 1. Listing detail ---
+  server.registerResource(
+    "listing",
+    new ResourceTemplate("guesty://listing/{id}", {
+      list: async () =>
+        listTopN("/listings", (l) => `guesty://listing/${l._id}`),
+    }),
+    {
+      title: "Guesty Listing",
+      description: "Full detail for a single Guesty listing (property).",
+      mimeType: "application/json",
+    },
+    async (uri, { id }) => {
+      try {
+        const data = await guestyGet(`/listings/${id}`);
+        return asJsonResource(uri, data);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  // --- 2. Reservation detail ---
+  server.registerResource(
+    "reservation",
+    new ResourceTemplate("guesty://reservation/{id}", {
+      list: async () =>
+        listTopN("/reservations", (r) => `guesty://reservation/${r._id}`),
+    }),
+    {
+      title: "Guesty Reservation",
+      description: "Full detail for a single reservation incl. guest, dates, money.",
+      mimeType: "application/json",
+    },
+    async (uri, { id }) => {
+      try {
+        const data = await guestyGet(`/reservations/${id}`);
+        return asJsonResource(uri, data);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  // --- 3. Review detail ---
+  server.registerResource(
+    "review",
+    new ResourceTemplate("guesty://review/{id}", {
+      list: async () =>
+        listTopN("/reviews", (r) => `guesty://review/${r._id}`),
+    }),
+    {
+      title: "Guesty Review",
+      description: "Full detail for a single review (Airbnb, Booking.com, etc.).",
+      mimeType: "application/json",
+    },
+    async (uri, { id }) => {
+      try {
+        const data = await guestyGet(`/reviews/${id}`);
+        return asJsonResource(uri, data);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  // --- 4. Guest profile ---
+  server.registerResource(
+    "guest",
+    new ResourceTemplate("guesty://guest/{id}", {
+      list: async () =>
+        listTopN("/guests", (g) => `guesty://guest/${g._id}`),
+    }),
+    {
+      title: "Guesty Guest",
+      description: "Guest profile: contact, tags, prior-stay history.",
+      mimeType: "application/json",
+    },
+    async (uri, { id }) => {
+      try {
+        const data = await guestyGet(`/guests/${id}`);
+        return asJsonResource(uri, data);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  // --- 5. Message thread ---
+  server.registerResource(
+    "thread",
+    new ResourceTemplate("guesty://thread/{conversation_id}", {
+      // No bulk-list for threads (usually fetched per-reservation).
+      list: undefined,
+    }),
+    {
+      title: "Guesty Message Thread",
+      description: "All messages on a single conversation thread.",
+      mimeType: "application/json",
+    },
+    async (uri, { conversation_id }) => {
+      try {
+        const data = await guestyGet(
+          `/communication/conversations/${conversation_id}/messages`,
+          { limit: 100 }
+        );
+        return asJsonResource(uri, data);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  // --- 6. Monthly revenue snapshot ---
+  // Uses the existing /reservations endpoint filtered by checkInFrom/checkInTo.
+  // Month format: YYYY-MM. Returns aggregate money fields.
+  server.registerResource(
+    "revenue-month",
+    new ResourceTemplate("guesty://report/revenue/{month}", {
+      list: undefined,
+    }),
+    {
+      title: "Monthly Revenue",
+      description:
+        "Aggregate revenue snapshot for a given month (YYYY-MM). Sums nightly rate, cleaning, extras, discounts.",
+      mimeType: "application/json",
+    },
+    async (uri, { month }) => {
+      try {
+        // Validate YYYY-MM
+        if (!/^\d{4}-\d{2}$/.test(month)) {
+          return asErrorResource(uri, new Error(`Invalid month '${month}' — expected YYYY-MM`));
+        }
+        const [year, mo] = month.split("-").map(Number);
+        const from = `${month}-01`;
+        const lastDay = new Date(year, mo, 0).getDate();
+        const to = `${month}-${String(lastDay).padStart(2, "0")}`;
+
+        const data = await guestyGet("/reservations", {
+          limit: 100,
+          "checkIn[$gte]": from,
+          "checkIn[$lte]": to,
+          status: "confirmed",
+        });
+        const results = data.results || [];
+
+        const agg = results.reduce(
+          (acc, r) => {
+            const m = r.money || {};
+            acc.count += 1;
+            acc.nights += r.nightsCount || 0;
+            acc.fareAccommodation += m.fareAccommodation || 0;
+            acc.fareCleaning += m.fareCleaning || 0;
+            acc.hostPayout += m.hostPayout || 0;
+            acc.totalPaid += m.totalPaid || 0;
+            return acc;
+          },
+          {
+            month,
+            count: 0,
+            nights: 0,
+            fareAccommodation: 0,
+            fareCleaning: 0,
+            hostPayout: 0,
+            totalPaid: 0,
+          }
+        );
+
+        return asJsonResource(uri, agg);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  // --- 7. Open tasks for a listing ---
+  server.registerResource(
+    "listing-tasks",
+    new ResourceTemplate("guesty://listing/{listing_id}/tasks", {
+      list: undefined,
+    }),
+    {
+      title: "Open Tasks for Listing",
+      description: "All open/pending tasks for a given listing.",
+      mimeType: "application/json",
+    },
+    async (uri, { listing_id }) => {
+      try {
+        const data = await guestyGet("/tasks", {
+          listingId: listing_id,
+          status: "pending",
+          limit: 50,
+        });
+        return asJsonResource(uri, data);
+      } catch (e) {
+        return asErrorResource(uri, e);
+      }
+    }
+  );
+
+  console.error("[resources] Registered 7 Guesty resource templates (guesty://)");
+}

package/src/server.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 import { getTier, getTierInfo, gatedHandler, FREE_TOOLS } from './license.js';
 import { registerIoTTools } from './iot-tools.js';
 import { registerEnterpriseTools } from './enterprise-tools.js';
+import { registerResources } from './resources.js';
 import { initDB } from './iot-db.js';
 
 // Guesty API Configuration
@@ -42,6 +43,33 @@ async function getToken() {
   return cachedToken;
 }
 
+// ISSUE_1_FIX (2026-04-22 CTO): shared filter builder for /reservations queries.
+// Guesty Open API v1 ignores `checkIn[$gte]`/`checkIn[$lte]` bracket-style
+// query params — it requires a JSON `filters=[{field,operator,from,to}]` array.
+// When filters are present, `listingId` is ALSO ignored as a top-level param
+// and must move *inside* the filter array. No `context:"now"` — that scopes
+// results to upcoming-only (the bug abada1987 reported in Issue #1).
+export function buildReservationFilters({ listingId, checkInFrom, checkInTo, checkOutFrom, checkOutTo, status } = {}) {
+  const filters = [];
+  if (listingId) filters.push({ field: "listingId", operator: "$eq", value: listingId });
+  if (status) filters.push({ field: "status", operator: "$eq", value: status });
+  if (checkInFrom && checkInTo) {
+    filters.push({ field: "checkIn", operator: "$between", from: checkInFrom, to: checkInTo });
+  } else if (checkInFrom) {
+    filters.push({ field: "checkIn", operator: "$gte", value: checkInFrom });
+  } else if (checkInTo) {
+    filters.push({ field: "checkIn", operator: "$lte", value: checkInTo });
+  }
+  if (checkOutFrom && checkOutTo) {
+    filters.push({ field: "checkOut", operator: "$between", from: checkOutFrom, to: checkOutTo });
+  } else if (checkOutFrom) {
+    filters.push({ field: "checkOut", operator: "$gte", value: checkOutFrom });
+  } else if (checkOutTo) {
+    filters.push({ field: "checkOut", operator: "$lte", value: checkOutTo });
+  }
+  return filters;
+}
+
 export async function guestyGet(path, params = {}, retries = 2) {
   const token = await getToken();
   const url = new URL(`${GUESTY_API_BASE}${path}`);
@@ -128,7 +156,7 @@ async function guestyDelete(path, retries = 2) {
 // Create MCP Server
 const server = new McpServer({
   name: "guesty-mcp-server",
-  version: "0.7.0",
+  version: "0.9.1",
 });
 // License tier check
 const _tier = getTier();
@@ -157,12 +185,14 @@ server.tool(
       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;
+    // ISSUE_1_FIX (2026-04-22): use Open API `filters` JSON array instead of
+    // `checkIn[$gte]`/`[$lte]` bracket params (silently ignored → upcoming-only).
+    const filters = buildReservationFilters(params);
+    if (filters.length > 0) {
+      queryParams.filters = JSON.stringify(filters);
+    } else if (params.listingId) {
+      queryParams.listingId = params.listingId;
+    }
 
     const data = await guestyGet("/reservations", queryParams);
 
@@ -297,9 +327,18 @@ server.tool(
       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;
+    // ISSUE_1_FIX (2026-04-22): filters array for historical windows
+    // (bracket-style params were silently ignored → upcoming-only).
+    const filters = buildReservationFilters({
+      listingId: params.listingId,
+      checkInFrom: params.from,
+      checkInTo: params.to,
+    });
+    if (filters.length > 0) {
+      queryParams.filters = JSON.stringify(filters);
+    } else if (params.listingId) {
+      queryParams.listingId = params.listingId;
+    }
 
     const data = await guestyGet("/reservations", queryParams);
     const financials = (data.results || []).map((r) => ({
@@ -538,12 +577,18 @@ server.tool(
     if (params.to) queryParams["to"] = params.to;
 
     // Owner statements not available via Open API v1 — fall back to financial data from reservations
+    // ISSUE_1_FIX (2026-04-22): same bracket→filters rewrite as Issue #1 sibling tools.
+    const ownerFilters = buildReservationFilters({
+      listingId: params.listingId,
+      checkInFrom: params.from,
+      checkInTo: params.to,
+    });
     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 }),
+      ...(ownerFilters.length > 0
+        ? { filters: JSON.stringify(ownerFilters) }
+        : (params.listingId ? { listingId: params.listingId } : {})),
     });
     const results = (resData.results || []).map((r) => ({
       guest: r.guest?.fullName || "Unknown",
@@ -1055,20 +1100,76 @@ server.tool(
   },
   { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
   async (params) => {
+    // ISSUE_1_FIX (2026-04-22): Open API calendar returns the day array under
+    // `data.days`, `data.data`, `data.results`, or as a bare top-level array
+    // depending on endpoint variant. Previous code only looked at `data.days`
+    // → totalDays:0 when response came back in any other shape (the bug
+    // abada1987 flagged as "all-zero totals" in Issue #1).
+    // Also: pass both `from`/`to` and `startDate`/`endDate` to be forgiving
+    // across Open API v1 calendar route versions.
     const data = await guestyGet(`/listings/${params.listingId}/calendar`, {
       from: params.from,
       to: params.to,
+      startDate: params.from,
+      endDate: params.to,
     });
 
-    const days = data.days || [];
+    // Normalize response shape across known Guesty calendar variants
+    let days = [];
+    if (Array.isArray(data)) days = data;
+    else if (Array.isArray(data?.days)) days = data.days;
+    else if (Array.isArray(data?.data)) days = data.data;
+    else if (Array.isArray(data?.results)) days = data.results;
+
+    // If the calendar endpoint didn't give us per-day rows, derive occupancy
+    // from reservations over the window so we never silently return 0.
+    if (days.length === 0 && params.from && params.to) {
+      const occupFilters = buildReservationFilters({
+        listingId: params.listingId,
+        checkInFrom: params.from,
+        checkInTo: params.to,
+      });
+      try {
+        const resData = await guestyGet("/reservations", {
+          limit: 100,
+          fields: "checkIn checkOut nightsCount status",
+          filters: JSON.stringify(occupFilters),
+        });
+        const totalDaysSpan = Math.max(1, Math.round((new Date(params.to) - new Date(params.from)) / 86400000) + 1);
+        const bookedDays = (resData.results || [])
+          .filter((r) => r.status === "confirmed" || r.status === "reserved")
+          .reduce((s, r) => s + (r.nightsCount || 0), 0);
+        const rate = Math.round((bookedDays / totalDaysSpan) * 10000) / 100;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              listing: params.listingId,
+              from: params.from,
+              to: params.to,
+              totalDays: totalDaysSpan,
+              bookedDays,
+              blockedDays: 0,
+              availableDays: Math.max(0, totalDaysSpan - bookedDays),
+              occupancyRate: `${rate}%`,
+              source: "reservations-derived",
+            }, null, 2),
+          }],
+        };
+      } catch (e) {
+        // fall through to zero-day response
+      }
+    }
+
     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++;
+      const s = d.status || d.state;
+      if (s === "booked" || s === "reserved") bookedDays++;
+      else if (s === "unavailable" || s === "blocked") blockedDays++;
       else availableDays++;
     });
 
@@ -1108,11 +1209,23 @@ server.tool(
       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;
+    // ISSUE_1_FIX (2026-04-22): filters array for historical windows.
+    // `status: "confirmed"` moved into filters so it survives alongside
+    // listingId + date window (top-level status was silently dropped when
+    // filters were later set on other paths).
+    const filters = buildReservationFilters({
+      listingId: params.listingId,
+      checkInFrom: params.from,
+      checkInTo: params.to,
+      status: "confirmed",
+    });
+    if (filters.length > 0) {
+      queryParams.filters = JSON.stringify(filters);
+    } else {
+      queryParams.status = "confirmed";
+      if (params.listingId) queryParams.listingId = params.listingId;
+    }
 
     const data = await guestyGet("/reservations", queryParams);
     const reservations = data.results || [];
@@ -1425,6 +1538,7 @@ server.tool(
 initDB();
 registerIoTTools(server);
 registerEnterpriseTools(server);
+registerResources(server, { guestyGet });
 
 // Start server
 const transport = new StdioServerTransport();