@burdenoff/mcp-libs 2026.626.1 → 2026.627.1

package/dist/modules/ggnomad/index.js

@@ -0,0 +1,1007 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/ggnomad/operations.ts
+var PROVIDER_FIELDS = `
+  id name type description contactEmail contactPhone website status
+  rating reviewCount listingCount totalRevenue workspaceId createdAt updatedAt
+`;
+var PROPERTY_FIELDS = `
+  id name type description address amenities bedrooms bathrooms maxGuests
+  pricePerNight currency checkInTime checkOutTime images rating reviewCount
+  status providerId workspaceId createdAt updatedAt
+  provider { id name type status }
+`;
+var ACTIVITY_FIELDS = `
+  id name category description duration difficulty price currency location
+  images includes requirements maxParticipants rating reviewCount safetyInfo
+  status providerId workspaceId createdAt updatedAt
+  provider { id name type status }
+`;
+var EVENT_FIELDS = `
+  id name category description venue startsAt endsAt price currency images
+  performers rating reviewCount status providerId workspaceId createdAt updatedAt
+  provider { id name type status }
+`;
+var TOUR_FIELDS = `
+  id name type description duration difficulty price currency location
+  highlights languages images maxGroupSize guideName rating reviewCount
+  status providerId workspaceId createdAt updatedAt
+  provider { id name type status }
+`;
+var TRIP_FIELDS = `
+  id name transportMode origin destination departureAt arrivalAt isRoundTrip
+  returnDepartureAt returnArrivalAt passengers class carrier price currency
+  ecoFriendly status workspaceId createdAt updatedAt
+`;
+var BOOKING_FIELDS = `
+  id bookingType referenceCode itemId itemName guestName guestEmail guestPhone
+  guests checkIn checkOut eventDate totalPrice currency paymentMethod
+  paymentStatus status specialRequests workspaceId createdAt updatedAt
+`;
+var ANALYTICS_FIELDS = `
+  conversionRate monthlyTrends revenueByCategory topDestinations
+  totalBookings totalRevenue totalUsers
+`;
+var OVERVIEW_FIELDS = `
+  bookings listings monthlyRevenue users
+`;
+var GET_PROVIDER = `
+  query GgnomadGetProvider($id: ID!) {
+    ggnomadProvider(id: $id) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var LIST_PROVIDERS = `
+  query GgnomadListProviders($pagination: GgnomadPaginationInput) {
+    ggnomadProviders(pagination: $pagination) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var CREATE_PROVIDER = `
+  mutation GgnomadCreateProvider($input: CreateGgnomadProviderInput!) {
+    createGgnomadProvider(input: $input) {
+      ${PROVIDER_FIELDS}
+    }
+  }
+`;
+var GET_PROPERTY = `
+  query GgnomadGetProperty($id: ID!) {
+    ggnomadProperty(id: $id) {
+      ${PROPERTY_FIELDS}
+    }
+  }
+`;
+var LIST_PROPERTIES = `
+  query GgnomadListProperties($pagination: GgnomadPaginationInput) {
+    ggnomadProperties(pagination: $pagination) {
+      ${PROPERTY_FIELDS}
+    }
+  }
+`;
+var CREATE_PROPERTY = `
+  mutation GgnomadCreateProperty($input: CreateGgnomadPropertyInput!) {
+    createGgnomadProperty(input: $input) {
+      ${PROPERTY_FIELDS}
+    }
+  }
+`;
+var GET_ACTIVITY = `
+  query GgnomadGetActivity($id: ID!) {
+    ggnomadActivity(id: $id) {
+      ${ACTIVITY_FIELDS}
+    }
+  }
+`;
+var LIST_ACTIVITIES = `
+  query GgnomadListActivities($pagination: GgnomadPaginationInput) {
+    ggnomadActivities(pagination: $pagination) {
+      ${ACTIVITY_FIELDS}
+    }
+  }
+`;
+var GET_EVENT = `
+  query GgnomadGetEvent($id: ID!) {
+    ggnomadEvent(id: $id) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var LIST_EVENTS = `
+  query GgnomadListEvents($pagination: GgnomadPaginationInput) {
+    ggnomadEvents(pagination: $pagination) {
+      ${EVENT_FIELDS}
+    }
+  }
+`;
+var GET_TOUR = `
+  query GgnomadGetTour($id: ID!) {
+    ggnomadTour(id: $id) {
+      ${TOUR_FIELDS}
+    }
+  }
+`;
+var LIST_TOURS = `
+  query GgnomadListTours($pagination: GgnomadPaginationInput) {
+    ggnomadTours(pagination: $pagination) {
+      ${TOUR_FIELDS}
+    }
+  }
+`;
+var LIST_TRIPS = `
+  query GgnomadListTrips($pagination: GgnomadPaginationInput) {
+    ggnomadTrips(pagination: $pagination) {
+      ${TRIP_FIELDS}
+    }
+  }
+`;
+var LIST_BOOKINGS = `
+  query GgnomadListBookings($pagination: GgnomadPaginationInput) {
+    ggnomadBookings(pagination: $pagination) {
+      ${BOOKING_FIELDS}
+    }
+  }
+`;
+var CREATE_BOOKING = `
+  mutation GgnomadCreateBooking($input: CreateGgnomadBookingInput!) {
+    createGgnomadBooking(input: $input) {
+      ${BOOKING_FIELDS}
+    }
+  }
+`;
+var CANCEL_BOOKING = `
+  mutation GgnomadCancelBooking($id: ID!, $reason: String) {
+    cancelGgnomadBooking(id: $id, reason: $reason) {
+      ${BOOKING_FIELDS}
+    }
+  }
+`;
+var LIST_FAVORITES = `
+  query GgnomadListFavorites($pagination: GgnomadFavoritesPaginationInput) {
+    ggnomadFavorites(pagination: $pagination)
+  }
+`;
+var TOGGLE_FAVORITE = `
+  mutation GgnomadToggleFavorite($input: ToggleGgnomadFavoriteInput!) {
+    toggleGgnomadFavorite(input: $input)
+  }
+`;
+var ANALYTICS = `
+  query GgnomadAnalytics {
+    ggnomadAnalytics {
+      ${ANALYTICS_FIELDS}
+    }
+  }
+`;
+var OVERVIEW_STATS = `
+  query GgnomadOverviewStats {
+    ggnomadOverviewStats {
+      ${OVERVIEW_FIELDS}
+    }
+  }
+`;
+
+// src/modules/ggnomad/tools/providers.ts
+function registerProviderTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_get")),
+    {
+      title: "Get Provider",
+      description: "Fetch a single GGNomad hospitality provider by ID.",
+      inputSchema: { id: z.string().describe("Provider ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROVIDER, { id });
+        if (!data.ggnomadProvider) return errorResult(`Provider ${id} not found`);
+        return jsonResult(data.ggnomadProvider);
+      } catch (error) {
+        ctx.logger.error("ggnomad providers_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_list")),
+    {
+      title: "List Providers",
+      description: "List hospitality providers in the bound workspace, with first/skip pagination.",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROVIDERS, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadProviders);
+      } catch (error) {
+        ctx.logger.error("ggnomad providers_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list providers: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "providers_create")),
+    {
+      title: "Create Provider",
+      description: 'Onboard a new hospitality provider. `name` and `type` are required (type is a free-form provider class, e.g. "hotel", "tour_operator", "transport").',
+      inputSchema: {
+        name: z.string().min(1).describe("Provider display name"),
+        type: z.string().min(1).describe('Provider type, e.g. "hotel", "tour_operator", "transport"'),
+        description: z.string().optional().describe("Provider description"),
+        contactEmail: z.string().optional().describe("Contact email"),
+        contactPhone: z.string().optional().describe("Contact phone"),
+        website: z.string().optional().describe("Provider website URL")
+      }
+    },
+    async ({ name, type, description, contactEmail, contactPhone, website }) => {
+      try {
+        const input = { name, type };
+        if (description !== void 0) input.description = description;
+        if (contactEmail !== void 0) input.contactEmail = contactEmail;
+        if (contactPhone !== void 0) input.contactPhone = contactPhone;
+        if (website !== void 0) input.website = website;
+        const data = await ctx.gql.workspace.request(CREATE_PROVIDER, { input });
+        return jsonResult(data.createGgnomadProvider);
+      } catch (error) {
+        ctx.logger.error("ggnomad providers_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+z.enum(["CANCELLED", "CHECKED_IN", "COMPLETED", "CONFIRMED", "NO_SHOW", "PENDING", "REFUNDED"]).describe("Lifecycle status of a booking");
+var GgnomadBookingTypeEnum = z.enum(["ACTIVITY", "EVENT", "PROPERTY", "TOUR", "TRIP"]).describe("The kind of listing a booking or favorite targets");
+z.enum(["ACTIVE", "ARCHIVED", "DRAFT", "PAUSED", "PENDING_REVIEW"]).describe("Lifecycle/moderation status of a listing (property, activity, event, tour)");
+var JsonObject = z.record(z.string(), z.unknown());
+
+// src/modules/ggnomad/tools/properties.ts
+function registerPropertyTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "properties_get")),
+    {
+      title: "Get Property",
+      description: "Fetch a single bookable property (stay listing) by ID.",
+      inputSchema: { id: z.string().describe("Property ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROPERTY, { id });
+        if (!data.ggnomadProperty) return errorResult(`Property ${id} not found`);
+        return jsonResult(data.ggnomadProperty);
+      } catch (error) {
+        ctx.logger.error("ggnomad properties_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get property: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "properties_list")),
+    {
+      title: "List Properties",
+      description: "List bookable properties in the bound workspace, with first/skip pagination.",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROPERTIES, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadProperties);
+      } catch (error) {
+        ctx.logger.error("ggnomad properties_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list properties: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "properties_create")),
+    {
+      title: "Create Property",
+      description: 'List a new bookable property. `address` is required JSON; `amenities`/`images` are required arrays; `type` is a free-form class (e.g. "apartment", "villa", "hostel").',
+      inputSchema: {
+        name: z.string().min(1).describe("Property display name"),
+        type: z.string().min(1).describe('Property type, e.g. "apartment", "villa", "hostel"'),
+        address: JsonObject.describe("Address JSON ({ line1, city, country, lat, lng, ... })"),
+        amenities: z.array(z.string()).describe("Amenity tags (e.g. wifi, kitchen, parking)"),
+        images: z.array(z.string()).describe("Image URLs"),
+        maxGuests: z.number().int().describe("Maximum guest capacity"),
+        pricePerNight: z.number().describe("Nightly price"),
+        bedrooms: z.number().int().optional().describe("Number of bedrooms"),
+        bathrooms: z.number().int().optional().describe("Number of bathrooms"),
+        checkInTime: z.string().optional().describe('Check-in time, e.g. "15:00"'),
+        checkOutTime: z.string().optional().describe('Check-out time, e.g. "11:00"'),
+        currency: z.string().optional().describe("ISO currency code (default service currency)"),
+        description: z.string().optional().describe("Property description"),
+        providerId: z.string().optional().describe("Owning provider ID")
+      }
+    },
+    async ({
+      name,
+      type,
+      address,
+      amenities,
+      images,
+      maxGuests,
+      pricePerNight,
+      bedrooms,
+      bathrooms,
+      checkInTime,
+      checkOutTime,
+      currency,
+      description,
+      providerId
+    }) => {
+      try {
+        const input = {
+          name,
+          type,
+          address,
+          amenities,
+          images,
+          maxGuests,
+          pricePerNight
+        };
+        if (bedrooms !== void 0) input.bedrooms = bedrooms;
+        if (bathrooms !== void 0) input.bathrooms = bathrooms;
+        if (checkInTime !== void 0) input.checkInTime = checkInTime;
+        if (checkOutTime !== void 0) input.checkOutTime = checkOutTime;
+        if (currency !== void 0) input.currency = currency;
+        if (description !== void 0) input.description = description;
+        if (providerId !== void 0) input.providerId = providerId;
+        const data = await ctx.gql.workspace.request(CREATE_PROPERTY, { input });
+        return jsonResult(data.createGgnomadProperty);
+      } catch (error) {
+        ctx.logger.error("ggnomad properties_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create property: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerActivityTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "activities_get")),
+    {
+      title: "Get Activity",
+      description: "Fetch a single bookable activity/experience by ID.",
+      inputSchema: { id: z.string().describe("Activity ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ACTIVITY, { id });
+        if (!data.ggnomadActivity) return errorResult(`Activity ${id} not found`);
+        return jsonResult(data.ggnomadActivity);
+      } catch (error) {
+        ctx.logger.error("ggnomad activities_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get activity: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "activities_list")),
+    {
+      title: "List Activities",
+      description: "List bookable activities/experiences in the bound workspace (first/skip pagination).",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ACTIVITIES, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadActivities);
+      } catch (error) {
+        ctx.logger.error("ggnomad activities_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list activities: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEventTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_get")),
+    {
+      title: "Get Event",
+      description: "Fetch a single ticketed event by ID.",
+      inputSchema: { id: z.string().describe("Event ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_EVENT, { id });
+        if (!data.ggnomadEvent) return errorResult(`Event ${id} not found`);
+        return jsonResult(data.ggnomadEvent);
+      } catch (error) {
+        ctx.logger.error("ggnomad events_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get event: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "events_list")),
+    {
+      title: "List Events",
+      description: "List ticketed events in the bound workspace (first/skip pagination).",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_EVENTS, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadEvents);
+      } catch (error) {
+        ctx.logger.error("ggnomad events_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list events: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTourTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tours_get")),
+    {
+      title: "Get Tour",
+      description: "Fetch a single guided tour by ID.",
+      inputSchema: { id: z.string().describe("Tour ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_TOUR, { id });
+        if (!data.ggnomadTour) return errorResult(`Tour ${id} not found`);
+        return jsonResult(data.ggnomadTour);
+      } catch (error) {
+        ctx.logger.error("ggnomad tours_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get tour: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "tours_list")),
+    {
+      title: "List Tours",
+      description: "List guided tours in the bound workspace (first/skip pagination).",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TOURS, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadTours);
+      } catch (error) {
+        ctx.logger.error("ggnomad tours_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list tours: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTripTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "trips_list")),
+    {
+      title: "List Trips",
+      description: "List transport/travel trips in the bound workspace (first/skip pagination).",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TRIPS, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadTrips);
+      } catch (error) {
+        ctx.logger.error("ggnomad trips_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list trips: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerBookingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "bookings_list")),
+    {
+      title: "List Bookings",
+      description: "List bookings in the bound workspace (first/skip pagination).",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 20)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_BOOKINGS, { pagination: { first: first ?? 20, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadBookings);
+      } catch (error) {
+        ctx.logger.error("ggnomad bookings_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list bookings: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "bookings_create")),
+    {
+      title: "Create Booking",
+      description: "Create a guest booking against a listing. `itemId`/`itemName` snapshot the booked listing; `bookingType` selects the listing kind; supply `checkIn`/`checkOut` for stays, `eventDate` for events/activities.",
+      inputSchema: {
+        bookingType: GgnomadBookingTypeEnum.describe("Kind of listing being booked"),
+        itemId: z.string().min(1).describe("ID of the booked listing"),
+        itemName: z.string().min(1).describe("Snapshot name of the booked listing"),
+        guestName: z.string().min(1).describe("Lead guest name"),
+        guests: z.number().int().describe("Number of guests"),
+        totalPrice: z.number().describe("Total booking price"),
+        guestEmail: z.string().optional().describe("Guest email"),
+        guestPhone: z.string().optional().describe("Guest phone"),
+        checkIn: z.string().optional().describe("Check-in datetime (ISO 8601) \u2014 stays"),
+        checkOut: z.string().optional().describe("Check-out datetime (ISO 8601) \u2014 stays"),
+        eventDate: z.string().optional().describe("Event/activity datetime (ISO 8601) \u2014 events, activities, tours"),
+        currency: z.string().optional().describe("ISO currency code (default service currency)"),
+        paymentMethod: z.string().optional().describe('Payment method, e.g. "card", "upi"'),
+        specialRequests: z.string().optional().describe("Free-text special requests")
+      }
+    },
+    async ({
+      bookingType,
+      itemId,
+      itemName,
+      guestName,
+      guests,
+      totalPrice,
+      guestEmail,
+      guestPhone,
+      checkIn,
+      checkOut,
+      eventDate,
+      currency,
+      paymentMethod,
+      specialRequests
+    }) => {
+      try {
+        const input = {
+          bookingType,
+          itemId,
+          itemName,
+          guestName,
+          guests,
+          totalPrice
+        };
+        if (guestEmail !== void 0) input.guestEmail = guestEmail;
+        if (guestPhone !== void 0) input.guestPhone = guestPhone;
+        if (checkIn !== void 0) input.checkIn = checkIn;
+        if (checkOut !== void 0) input.checkOut = checkOut;
+        if (eventDate !== void 0) input.eventDate = eventDate;
+        if (currency !== void 0) input.currency = currency;
+        if (paymentMethod !== void 0) input.paymentMethod = paymentMethod;
+        if (specialRequests !== void 0) input.specialRequests = specialRequests;
+        const data = await ctx.gql.workspace.request(CREATE_BOOKING, { input });
+        return jsonResult(data.createGgnomadBooking);
+      } catch (error) {
+        ctx.logger.error("ggnomad bookings_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create booking: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "bookings_cancel")),
+    {
+      title: "Cancel Booking",
+      description: "Cancel a booking by ID, with an optional cancellation reason.",
+      inputSchema: {
+        id: z.string().describe("Booking ID"),
+        reason: z.string().optional().describe("Cancellation reason")
+      }
+    },
+    async ({ id, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CANCEL_BOOKING, { id, reason });
+        return jsonResult(data.cancelGgnomadBooking);
+      } catch (error) {
+        ctx.logger.error("ggnomad bookings_cancel failed", { error: String(error) });
+        return errorResult(
+          `Failed to cancel booking: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerFavoriteTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "favorites_list")),
+    {
+      title: "List Favorites",
+      description: "List the calling user's favorited listings (first/skip pagination, default page 50).",
+      inputSchema: {
+        first: z.number().int().optional().describe("Page size (default 50)"),
+        skip: z.number().int().optional().describe("Records to skip (default 0)")
+      }
+    },
+    async ({ first, skip }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_FAVORITES, { pagination: { first: first ?? 50, skip: skip ?? 0 } });
+        return jsonResult(data.ggnomadFavorites);
+      } catch (error) {
+        ctx.logger.error("ggnomad favorites_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list favorites: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "favorites_toggle")),
+    {
+      title: "Toggle Favorite",
+      description: "Toggle a listing in the calling user's favorites. Returns true if the listing is now favorited, false if it was removed.",
+      inputSchema: {
+        targetId: z.string().min(1).describe("ID of the listing to favorite/un-favorite"),
+        targetType: GgnomadBookingTypeEnum.describe("Kind of listing being targeted")
+      }
+    },
+    async ({ targetId, targetType }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          TOGGLE_FAVORITE,
+          { input: { targetId, targetType } }
+        );
+        return jsonResult({ favorited: data.toggleGgnomadFavorite });
+      } catch (error) {
+        ctx.logger.error("ggnomad favorites_toggle failed", { error: String(error) });
+        return errorResult(
+          `Failed to toggle favorite: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/ggnomad/tools/analytics.ts
+function registerAnalyticsTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analytics_metrics")),
+    {
+      title: "GGNomad Analytics",
+      description: "Marketplace-wide analytics: conversion rate, monthly trends, revenue by category, top destinations, and total users/bookings/revenue.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(ANALYTICS, {});
+        return jsonResult(data.ggnomadAnalytics);
+      } catch (error) {
+        ctx.logger.error("ggnomad analytics_metrics failed", { error: String(error) });
+        return errorResult(
+          `Failed to get analytics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "analytics_overview")),
+    {
+      title: "GGNomad Overview Stats",
+      description: "Headline marketplace KPIs: active listings, total bookings, total users, and monthly revenue.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(OVERVIEW_STATS, {});
+        return jsonResult(data.ggnomadOverviewStats);
+      } catch (error) {
+        ctx.logger.error("ggnomad analytics_overview failed", { error: String(error) });
+        return errorResult(
+          `Failed to get overview stats: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/ggnomad/resources.ts
+function registerGgnomadResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const overviewUri = track(mcpResourceUri(ctx.productName, "overview"));
+  const analyticsUri = track(mcpResourceUri(ctx.productName, "analytics"));
+  const propertiesUri = track(mcpResourceUri(ctx.productName, "properties"));
+  server.registerResource(
+    "ggnomad-schema",
+    schemaUri,
+    {
+      title: "GGNomad Domain Schema",
+      description: "Overview of the GGNomad travel + hospitality marketplace domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# GGNomad Domain (Overview)
+
+Nomad travel + hospitality marketplace: bookable stays, activities, events,
+guided tours, and trips, sold by providers and booked by guests.
+
+## Entities
+- GgnomadProvider \u2014 a hospitality business (hotel, tour operator, transport)
+- GgnomadProperty \u2014 a bookable stay listing
+- GgnomadActivity \u2014 a bookable experience/activity
+- GgnomadEvent \u2014 a ticketed event
+- GgnomadTour \u2014 a guided tour
+- GgnomadTrip \u2014 a transport/travel leg
+- GgnomadBooking \u2014 a guest booking against any listing
+
+## Enums
+- GgnomadBookingType: ACTIVITY, EVENT, PROPERTY, TOUR, TRIP
+- GgnomadBookingStatus: PENDING, CONFIRMED, CHECKED_IN, COMPLETED, CANCELLED, NO_SHOW, REFUNDED
+- GgnomadListingStatus: DRAFT, PENDING_REVIEW, ACTIVE, PAUSED, ARCHIVED
+
+## Tool groups
+providers, properties, activities, events, tours, trips, bookings, favorites, analytics.
+All run against the WORKSPACE gateway (workspace-scoped). Pagination is { first, skip }.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "ggnomad-overview",
+    overviewUri,
+    {
+      title: "GGNomad Overview Stats",
+      description: "Live headline marketplace KPIs (listings, bookings, users, monthly revenue).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${overviewUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          OVERVIEW_STATS,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: overviewUri,
+              text: JSON.stringify(data.ggnomadOverviewStats, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: overviewUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "ggnomad-analytics",
+    analyticsUri,
+    {
+      title: "GGNomad Analytics",
+      description: "Marketplace-wide analytics: conversion rate, monthly trends, revenue by category, top destinations, totals.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${analyticsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(ANALYTICS, {});
+        return {
+          contents: [
+            {
+              uri: analyticsUri,
+              text: JSON.stringify(data.ggnomadAnalytics, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: analyticsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "ggnomad-properties",
+    propertiesUri,
+    {
+      title: "GGNomad Property Directory",
+      description: "The first 50 bookable properties in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${propertiesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_PROPERTIES,
+          { pagination: { first: 50, skip: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: propertiesUri,
+              text: JSON.stringify(data.ggnomadProperties, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: propertiesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerGgnomadPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const onboardingName = track(mcpPromptName(p, "provider-onboarding"));
+  const opsName = track(mcpPromptName(p, "marketplace-ops"));
+  server.registerPrompt(
+    onboardingName,
+    {
+      title: "Provider Onboarding",
+      description: "Guide for onboarding a new GGNomad hospitality provider end to end: create the provider and list its first bookable property.",
+      argsSchema: {
+        name: z.string().optional().describe("Provider/business name"),
+        type: z.string().optional().describe('Provider type, e.g. "hotel", "tour_operator"')
+      }
+    },
+    ({ name, type }) => {
+      ctx.logger.debug(`Prompt ${onboardingName} called`, { name, type });
+      const nameNote = name ? `Use the business name "${name}".` : "Ask the user for the business name.";
+      const typeNote = type ? `Use provider type "${type}".` : "Help the user pick a provider type.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me onboard a new GGNomad hospitality provider.
+
+1. **Create Provider**: Use ${p}_providers_create. ${nameNote} ${typeNote} Optionally add contactEmail, contactPhone, and website.
+2. **List a Property**: Use ${p}_properties_create for the first stay \u2014 set the providerId from step 1, plus address JSON, amenities, images, maxGuests, and pricePerNight.
+3. **Verify**: Use ${p}_properties_list to confirm the property appears, and ${p}_providers_get to confirm the provider's listingCount.
+
+Show results at each step and confirm before listing more inventory.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "Marketplace Operations",
+      description: "Daily operations workflow: review KPIs, triage the booking queue, manage cancellations, and scan inventory.",
+      argsSchema: {
+        providerId: z.string().optional().describe("Provider ID to focus on")
+      }
+    },
+    ({ providerId }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { providerId });
+      const providerNote = providerId ? `Focus on provider "${providerId}".` : `First list providers with ${p}_providers_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run daily GGNomad marketplace operations. ${providerNote}
+
+1. **KPIs**: Use ${p}_analytics_overview for headline numbers and ${p}_analytics_metrics for trends, revenue by category, and top destinations.
+2. **Booking Queue**: Use ${p}_bookings_list to find PENDING/CONFIRMED bookings that need attention.
+3. **Cancellations**: For any booking that must be cancelled, use ${p}_bookings_cancel with a clear reason.
+4. **Inventory**: Scan ${p}_properties_list, ${p}_activities_list, ${p}_events_list, ${p}_tours_list, and ${p}_trips_list for listings needing updates.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/ggnomad/index.ts
+var ggnomadModule = {
+  id: "ggnomad",
+  version: "0.0.1",
+  displayName: "GGNomad",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerProviderTools(server, ctx, trackTool);
+    registerPropertyTools(server, ctx, trackTool);
+    registerActivityTools(server, ctx, trackTool);
+    registerEventTools(server, ctx, trackTool);
+    registerTourTools(server, ctx, trackTool);
+    registerTripTools(server, ctx, trackTool);
+    registerBookingTools(server, ctx, trackTool);
+    registerFavoriteTools(server, ctx, trackTool);
+    registerAnalyticsTools(server, ctx, trackTool);
+    registerGgnomadResources(server, ctx, trackResource);
+    registerGgnomadPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var ggnomad_default = ggnomadModule;
+
+export { ggnomad_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map