mcp-travelcode 1.0.0

package/build/formatters/aerodatabox-formatter.js

@@ -0,0 +1,246 @@
+// --- Helpers ---
+function extractLocalTime(endpoint) {
+    const time = endpoint.actualTime?.local ||
+        endpoint.revisedTime?.local ||
+        endpoint.predictedTime?.local ||
+        endpoint.scheduledTime?.local;
+    if (!time)
+        return undefined;
+    // Extract HH:mm from ISO string
+    const match = time.match(/T(\d{2}:\d{2})/);
+    return match ? match[1] : time;
+}
+function extractScheduledTime(endpoint) {
+    const time = endpoint.scheduledTime?.local;
+    if (!time)
+        return undefined;
+    const match = time.match(/T(\d{2}:\d{2})/);
+    return match ? match[1] : time;
+}
+function airportLabel(endpoint) {
+    const iata = endpoint.airport?.iata || "";
+    const name = endpoint.airport?.shortName || endpoint.airport?.name || endpoint.airport?.municipalityName || "";
+    if (iata && name)
+        return `${name} (${iata})`;
+    return iata || name || "Unknown";
+}
+function delayText(endpoint) {
+    const scheduled = endpoint.scheduledTime?.local;
+    const actual = endpoint.actualTime?.local || endpoint.revisedTime?.local || endpoint.predictedTime?.local;
+    if (!scheduled || !actual)
+        return "";
+    const schedDate = new Date(scheduled);
+    const actualDate = new Date(actual);
+    const diffMin = Math.round((actualDate.getTime() - schedDate.getTime()) / 60000);
+    if (diffMin <= 0)
+        return "On time";
+    return `+${diffMin} min delay`;
+}
+// --- Flight Status ---
+function formatOneFlight(flight) {
+    const lines = [];
+    const airline = flight.airline?.name || "";
+    const flightNum = flight.number || "";
+    const status = flight.status || "Unknown";
+    lines.push(`${flightNum} ${airline ? `— ${airline}` : ""}`);
+    lines.push(`Status: ${status}`);
+    lines.push("");
+    // Departure
+    const depAirport = airportLabel(flight.departure);
+    const depScheduled = extractScheduledTime(flight.departure);
+    const depActual = extractLocalTime(flight.departure);
+    const depDelay = delayText(flight.departure);
+    lines.push(`Departure: ${depAirport}`);
+    if (depScheduled)
+        lines.push(`  Scheduled: ${depScheduled}${flight.departure.terminal ? ` (Terminal ${flight.departure.terminal})` : ""}${flight.departure.gate ? `, Gate ${flight.departure.gate}` : ""}`);
+    if (depActual && depActual !== depScheduled)
+        lines.push(`  Actual:    ${depActual} ${depDelay}`);
+    else if (depDelay)
+        lines.push(`  ${depDelay}`);
+    // Arrival
+    const arrAirport = airportLabel(flight.arrival);
+    const arrScheduled = extractScheduledTime(flight.arrival);
+    const arrActual = extractLocalTime(flight.arrival);
+    const arrDelay = delayText(flight.arrival);
+    lines.push(`Arrival: ${arrAirport}`);
+    if (arrScheduled)
+        lines.push(`  Scheduled: ${arrScheduled}${flight.arrival.terminal ? ` (Terminal ${flight.arrival.terminal})` : ""}${flight.arrival.gate ? `, Gate ${flight.arrival.gate}` : ""}`);
+    if (arrActual && arrActual !== arrScheduled)
+        lines.push(`  Estimated: ${arrActual} ${arrDelay}`);
+    else if (arrDelay)
+        lines.push(`  ${arrDelay}`);
+    if (flight.arrival.baggageBelt) {
+        lines.push(`  Baggage belt: ${flight.arrival.baggageBelt}`);
+    }
+    // Aircraft
+    if (flight.aircraft) {
+        const parts = [];
+        if (flight.aircraft.model)
+            parts.push(flight.aircraft.model);
+        if (flight.aircraft.reg)
+            parts.push(`(${flight.aircraft.reg})`);
+        if (parts.length > 0) {
+            lines.push("");
+            lines.push(`Aircraft: ${parts.join(" ")}`);
+        }
+    }
+    // Distance
+    if (flight.greatCircleDistance?.km) {
+        lines.push(`Distance: ${Math.round(flight.greatCircleDistance.km).toLocaleString()} km`);
+    }
+    // Location (if in-flight)
+    if (flight.location?.lat && flight.location?.lon) {
+        lines.push("");
+        lines.push(`Current position: ${flight.location.lat.toFixed(2)}°, ${flight.location.lon.toFixed(2)}°`);
+        if (flight.location.pressureAltFt) {
+            lines.push(`Altitude: ${flight.location.pressureAltFt.toLocaleString()} ft`);
+        }
+    }
+    return lines;
+}
+export function formatFlightStatus(flights, flightNumber, date) {
+    if (!flights || flights.length === 0) {
+        return `No flight data found for ${flightNumber} on ${date}. Check the flight number and date.`;
+    }
+    const lines = [`Flight status: ${flightNumber} | ${date}\n`];
+    for (let i = 0; i < flights.length; i++) {
+        if (flights.length > 1) {
+            lines.push(`--- Leg ${i + 1} ---`);
+        }
+        lines.push(...formatOneFlight(flights[i]));
+        if (i < flights.length - 1)
+            lines.push("");
+    }
+    return lines.join("\n");
+}
+// --- Airport Board ---
+export function formatAirportBoard(flights, airportCode, direction, fromTime, toTime) {
+    const label = direction === "departure" ? "Departures" : "Arrivals";
+    const lines = [`${label} — ${airportCode} | ${fromTime} to ${toTime}\n`];
+    if (!flights || flights.length === 0) {
+        lines.push(`No ${direction}s found for this time window.`);
+        return lines.join("\n");
+    }
+    lines.push(`${flights.length} flight(s):\n`);
+    for (let i = 0; i < flights.length; i++) {
+        const f = flights[i];
+        const num = f.number || "—";
+        const airline = f.airline?.name || f.airline?.iata || "";
+        const status = f.status || "";
+        let destination;
+        let time;
+        let terminal;
+        let gate;
+        if (direction === "departure") {
+            destination = airportLabel(f.arrival);
+            time = extractScheduledTime(f.departure) || "—";
+            terminal = f.departure.terminal || "";
+            gate = f.departure.gate || "";
+        }
+        else {
+            destination = airportLabel(f.departure);
+            time = extractScheduledTime(f.arrival) || "—";
+            terminal = f.arrival.terminal || "";
+            gate = f.arrival.gate || "";
+        }
+        const statusBadge = status ? ` [${status}]` : "";
+        const termGate = [terminal ? `T${terminal}` : "", gate ? `Gate ${gate}` : ""].filter(Boolean).join(", ");
+        lines.push(`${i + 1}. ${time} | ${num} ${airline} → ${destination}${statusBadge}`);
+        if (termGate)
+            lines.push(`   ${termGate}`);
+    }
+    return lines.join("\n");
+}
+// --- Flight Delay Statistics ---
+export function formatFlightDelayStats(stats, flightNumber) {
+    const lines = [`Delay statistics: ${flightNumber}`];
+    if (stats.route?.from && stats.route?.to) {
+        lines[0] += ` (${stats.route.from} → ${stats.route.to})`;
+    }
+    lines.push("");
+    if (stats.observations !== undefined) {
+        lines.push(`Based on ${stats.observations} recent observations\n`);
+    }
+    if (stats.onTimePercentage !== undefined) {
+        lines.push(`On-time (< 15 min): ${stats.onTimePercentage.toFixed(0)}%`);
+    }
+    if (stats.delayDistribution) {
+        for (const bucket of stats.delayDistribution) {
+            if (bucket.bucket && bucket.percentage !== undefined) {
+                lines.push(`Delayed ${bucket.bucket} min: ${bucket.percentage.toFixed(0)}%`);
+            }
+        }
+    }
+    if (stats.cancelledPercentage !== undefined) {
+        lines.push(`Cancelled: ${stats.cancelledPercentage.toFixed(1)}%`);
+    }
+    lines.push("");
+    if (stats.averageDelayMin !== undefined) {
+        lines.push(`Average delay: ${Math.round(stats.averageDelayMin)} min`);
+    }
+    if (stats.medianDelayMin !== undefined) {
+        lines.push(`Median delay: ${Math.round(stats.medianDelayMin)} min`);
+    }
+    // Assessment
+    lines.push("");
+    if (stats.onTimePercentage !== undefined) {
+        if (stats.onTimePercentage >= 80) {
+            lines.push("Assessment: Very reliable — on time most flights.");
+        }
+        else if (stats.onTimePercentage >= 60) {
+            lines.push("Assessment: Generally reliable — on time about 2 out of 3 flights.");
+        }
+        else if (stats.onTimePercentage >= 40) {
+            lines.push("Assessment: Moderate delays — frequently delayed.");
+        }
+        else {
+            lines.push("Assessment: Unreliable — often delayed significantly.");
+        }
+    }
+    return lines.join("\n");
+}
+// --- Airport Delay Statistics ---
+export function formatAirportDelayStats(stats, airportCode, date) {
+    const airportName = stats.airport?.name || airportCode;
+    const lines = [`Airport delay statistics: ${airportName} (${airportCode}) | ${date}\n`];
+    if (stats.departures) {
+        const d = stats.departures;
+        lines.push("Departures:");
+        if (d.averageDelayMin !== undefined)
+            lines.push(`  Average delay: ${Math.round(d.averageDelayMin)} min`);
+        if (d.medianDelayMin !== undefined)
+            lines.push(`  Median delay: ${Math.round(d.medianDelayMin)} min`);
+        if (d.cancellations !== undefined && d.totalFlights !== undefined) {
+            const pct = d.totalFlights > 0 ? ((d.cancellations / d.totalFlights) * 100).toFixed(1) : "0";
+            lines.push(`  Cancellations: ${d.cancellations} of ${d.totalFlights} flights (${pct}%)`);
+        }
+        lines.push(`  Status: ${assessDelay(d.averageDelayMin)}`);
+        lines.push("");
+    }
+    if (stats.arrivals) {
+        const a = stats.arrivals;
+        lines.push("Arrivals:");
+        if (a.averageDelayMin !== undefined)
+            lines.push(`  Average delay: ${Math.round(a.averageDelayMin)} min`);
+        if (a.medianDelayMin !== undefined)
+            lines.push(`  Median delay: ${Math.round(a.medianDelayMin)} min`);
+        if (a.cancellations !== undefined && a.totalFlights !== undefined) {
+            const pct = a.totalFlights > 0 ? ((a.cancellations / a.totalFlights) * 100).toFixed(1) : "0";
+            lines.push(`  Cancellations: ${a.cancellations} of ${a.totalFlights} flights (${pct}%)`);
+        }
+        lines.push(`  Status: ${assessDelay(a.averageDelayMin)}`);
+    }
+    return lines.join("\n");
+}
+function assessDelay(avgDelayMin) {
+    if (avgDelayMin === undefined)
+        return "No data";
+    if (avgDelayMin <= 10)
+        return "Normal operations";
+    if (avgDelayMin <= 20)
+        return "Minor delays";
+    if (avgDelayMin <= 40)
+        return "Moderate delays";
+    return "Severe delays";
+}
+//# sourceMappingURL=aerodatabox-formatter.js.map

package/build/formatters/airline-formatter.d.ts

@@ -0,0 +1,3 @@
+import { Airline } from "../client/types.js";
+export declare function formatAirlineList(airlines: Airline[], query: string): string;
+//# sourceMappingURL=airline-formatter.d.ts.map

package/build/formatters/airline-formatter.js

@@ -0,0 +1,12 @@
+export function formatAirlineList(airlines, query) {
+    if (airlines.length === 0) {
+        return `No airlines found matching "${query}". Try a different search term (airline name or IATA code).`;
+    }
+    const lines = [`Found ${airlines.length} airline(s) matching "${query}":\n`];
+    for (let i = 0; i < airlines.length; i++) {
+        const a = airlines[i];
+        lines.push(`${i + 1}. ${a.code} — ${a.title}`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=airline-formatter.js.map

package/build/formatters/airport-formatter.d.ts

@@ -0,0 +1,4 @@
+import { Airport } from "../client/types.js";
+export declare function formatAirportList(airports: Airport[], query: string): string;
+export declare function formatAirportDetail(airport: Airport): string;
+//# sourceMappingURL=airport-formatter.d.ts.map

package/build/formatters/airport-formatter.js

@@ -0,0 +1,28 @@
+export function formatAirportList(airports, query) {
+    if (airports.length === 0) {
+        return `No airports found matching "${query}". Try a different search term (city name, airport name, or IATA code).`;
+    }
+    const lines = [`Found ${airports.length} result(s) matching "${query}":\n`];
+    for (let i = 0; i < airports.length; i++) {
+        const a = airports[i];
+        const type = a.isAirport === false ? "City" : "Airport";
+        const country = a.country ? `, ${a.country.titleEn}` : "";
+        const city = a.city ? `${a.city.titleEn}, ` : "";
+        lines.push(`${i + 1}. ${a.code} — ${a.titleEn} [${type}]`);
+        lines.push(`   ${city}${a.country?.titleEn || ""}`);
+    }
+    return lines.join("\n");
+}
+export function formatAirportDetail(airport) {
+    const lines = [];
+    const type = airport.isAirport === false ? "City" : "Airport";
+    lines.push(`${type}: ${airport.titleEn} (${airport.code})`);
+    if (airport.city) {
+        lines.push(`City: ${airport.city.titleEn} (${airport.city.code})`);
+    }
+    if (airport.country) {
+        lines.push(`Country: ${airport.country.titleEn} (${airport.country.code})`);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=airport-formatter.js.map

package/build/formatters/flight-formatter.d.ts

@@ -0,0 +1,13 @@
+import { FlightSearchResultsResponse } from "../client/types.js";
+interface SearchMeta {
+    origin: string;
+    destination: string;
+    departureDate: string;
+    returnDate?: string;
+    cabinClass: string;
+    passengers: string;
+}
+export declare function formatFlightResults(response: FlightSearchResultsResponse, cacheId: string, meta: SearchMeta, completed: boolean): string;
+export declare function formatFilteredResults(response: FlightSearchResultsResponse, cacheId: string, filterSummary: string): string;
+export {};
+//# sourceMappingURL=flight-formatter.d.ts.map

package/build/formatters/flight-formatter.js

@@ -0,0 +1,100 @@
+function formatItinerary(itinerary, label) {
+    const lines = [];
+    const segments = itinerary.segments;
+    if (segments.length === 0)
+        return lines;
+    const firstSeg = segments[0];
+    const lastSeg = segments[segments.length - 1];
+    const depTime = firstSeg.departure.at.split("T")[1]?.substring(0, 5) || "";
+    const arrTime = lastSeg.arrival.at.split("T")[1]?.substring(0, 5) || "";
+    const depCode = firstSeg.departure.iata_code;
+    const arrCode = lastSeg.arrival.iata_code;
+    const stops = itinerary.transfers;
+    const stopsText = stops === 0 ? "Direct" : stops === 1 ? "1 stop" : `${stops} stops`;
+    // Flight numbers
+    const flightNums = segments.map((s) => `${s.carrier_code}${s.number}`).join(", ");
+    lines.push(`   ${label}: ${depCode} ${depTime} → ${arrCode} ${arrTime} (${itinerary.duration}) | ${stopsText}`);
+    lines.push(`   Flights: ${flightNums}`);
+    // Show layover airports for connecting flights
+    if (stops > 0) {
+        const connections = segments.slice(0, -1).map((s) => s.arrival.iata_code);
+        lines.push(`   Via: ${connections.join(", ")}`);
+    }
+    return lines;
+}
+function formatOffer(offer, index, currencySign, airlineNames) {
+    const lines = [];
+    const item = offer.items[0];
+    if (!item)
+        return `${index}. (no offer data)`;
+    const airlineName = airlineNames[item.airline] || item.airline;
+    const baggageText = item.includeBaggage
+        ? item.include_baggage
+            ? `${item.include_baggage.count} ${item.include_baggage.unit} baggage included`
+            : "Baggage included"
+        : "No baggage";
+    lines.push(`${index}. ${airlineName} (${item.airline}) | ${currencySign}${offer.totalPrice}`);
+    // Itineraries
+    const itineraries = item.itineraries;
+    if (itineraries.length >= 1) {
+        lines.push(...formatItinerary(itineraries[0], "Outbound"));
+    }
+    if (itineraries.length >= 2) {
+        lines.push(...formatItinerary(itineraries[1], "Return"));
+    }
+    lines.push(`   ${item.cabinClass} | ${baggageText} | ${item.availableSeats} seats left`);
+    return lines.join("\n");
+}
+export function formatFlightResults(response, cacheId, meta, completed) {
+    const lines = [];
+    // Header
+    const tripType = meta.returnDate ? "Round trip" : "One way";
+    lines.push(`Flight search: ${meta.origin} → ${meta.destination}`);
+    lines.push(`${tripType} | ${meta.departureDate}${meta.returnDate ? ` — ${meta.returnDate}` : ""} | ${meta.cabinClass} | ${meta.passengers}`);
+    lines.push("");
+    if (!completed) {
+        lines.push("(Search still in progress — showing partial results)");
+        lines.push("");
+    }
+    const total = response.total || response.items.length;
+    lines.push(`Found ${total} flight option(s). Showing ${response.items.length}:\n`);
+    const airlineNames = response.airlines || {};
+    const currencySign = response.currencySign || response.currency || "$";
+    for (let i = 0; i < response.items.length; i++) {
+        lines.push(formatOffer(response.items[i], i + 1, currencySign, airlineNames));
+        if (i < response.items.length - 1)
+            lines.push("");
+    }
+    if (response.items.length === 0) {
+        lines.push("No flights found for this route and date. Try different dates or airports.");
+    }
+    lines.push("");
+    lines.push(`Cache ID: ${cacheId}`);
+    lines.push("Use get_flight_results with this cache ID to filter, sort, or see more results.");
+    return lines.join("\n");
+}
+export function formatFilteredResults(response, cacheId, filterSummary) {
+    const lines = [];
+    lines.push(`Flight results (cache: ${cacheId})`);
+    if (filterSummary) {
+        lines.push(`Filters: ${filterSummary}`);
+    }
+    const total = response.total || response.items.length;
+    const offset = response.offset || 0;
+    const showing = response.items.length;
+    lines.push(`Showing ${offset + 1}–${offset + showing} of ${total} result(s)\n`);
+    const airlineNames = response.airlines || {};
+    const currencySign = response.currencySign || response.currency || "$";
+    for (let i = 0; i < response.items.length; i++) {
+        lines.push(formatOffer(response.items[i], offset + i + 1, currencySign, airlineNames));
+        if (i < response.items.length - 1)
+            lines.push("");
+    }
+    if (response.items.length === 0) {
+        lines.push("No flights match these filters. Try relaxing your criteria.");
+    }
+    lines.push("");
+    lines.push(`Cache ID: ${cacheId}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=flight-formatter.js.map

package/build/formatters/hotel-formatter.d.ts

@@ -0,0 +1,4 @@
+import { HotelLocationSearchResponse, HotelOffer } from "../client/types.js";
+export declare function formatHotelLocations(data: HotelLocationSearchResponse): string;
+export declare function formatHotelResults(hotels: HotelOffer[], totalCount: number): string;
+//# sourceMappingURL=hotel-formatter.d.ts.map

package/build/formatters/hotel-formatter.js

@@ -0,0 +1,55 @@
+export function formatHotelLocations(data) {
+    if (!data.items || data.items.length === 0) {
+        return "No locations found.";
+    }
+    const lines = [`Found ${data.items.length} group(s):\n`];
+    for (const group of data.items) {
+        lines.push(`--- ${group.type.toUpperCase()}: ${group.text} ---`);
+        for (const child of group.children) {
+            const idHint = group.type === "hotels" ? `(use location: ${child.id})` : `(use location: ${child.id})`;
+            const addr = child.address ? ` — ${child.address}` : "";
+            lines.push(`  ID: ${child.id} ${idHint}  ${child.name}${addr}  [${child.countryCode}]`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+const BOARD_NAMES = {
+    RO: "Room Only",
+    BI: "Breakfast Included",
+    LI: "Lunch Included",
+    DI: "Dinner Included",
+    HB: "Half Board",
+    FB: "Full Board",
+    AI: "All Inclusive",
+};
+export function formatHotelResults(hotels, totalCount) {
+    if (hotels.length === 0) {
+        return totalCount > 0
+            ? `Found ${totalCount} hotels total, but none in the current page. Try adjusting offset/limit or filters.`
+            : "No hotels found matching your criteria.";
+    }
+    const lines = [`Found ${totalCount} hotels total. Showing ${hotels.length}:\n`];
+    for (const hotel of hotels) {
+        const starRating = hotel.starRating ?? hotel.stars;
+        const stars = starRating ? "★".repeat(starRating) : "";
+        const name = hotel.propertyName ?? hotel.name ?? "Unknown Hotel";
+        const pricePerNight = hotel.price != null ? `$${hotel.price}` : "N/A";
+        const totalPrice = hotel.total != null ? `$${hotel.total}` : "";
+        const boardCode = hotel.boardCode ?? hotel.board ?? "";
+        const mealName = hotel.meal ?? BOARD_NAMES[boardCode] ?? boardCode;
+        const refundable = hotel.refundable;
+        const refundText = refundable === true ? "Refundable" : refundable === false ? "Non-refundable" : "";
+        const partner = hotel.partnerName ?? "";
+        lines.push(`${stars} ${name}`);
+        lines.push(`  Price: ${pricePerNight}/night${totalPrice ? ` (total: ${totalPrice})` : ""}`);
+        if (mealName)
+            lines.push(`  Meal: ${mealName}`);
+        const tags = [refundText, partner].filter(Boolean).join(" | ");
+        if (tags)
+            lines.push(`  ${tags}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=hotel-formatter.js.map

package/build/formatters/order-formatter.d.ts

@@ -0,0 +1,8 @@
+import { OrderList, OrderFull, CancelCheckResponse, CancelResult, ModifyCheckResponse, ModifyResult } from "../client/types.js";
+export declare function formatOrderList(data: OrderList): string;
+export declare function formatOrderDetail(order: OrderFull): string;
+export declare function formatCancelCheck(data: CancelCheckResponse, orderId: number): string;
+export declare function formatCancelResult(data: CancelResult): string;
+export declare function formatModifyCheck(data: ModifyCheckResponse, orderId: number): string;
+export declare function formatModifyResult(data: ModifyResult): string;
+//# sourceMappingURL=order-formatter.d.ts.map

package/build/formatters/order-formatter.js

@@ -0,0 +1,115 @@
+export function formatOrderList(data) {
+    const lines = [];
+    lines.push(`Orders: showing ${data.items.length} of ${data.total} (offset ${data.offset})`);
+    lines.push("");
+    if (data.items.length === 0) {
+        lines.push("No orders found.");
+        return lines.join("\n");
+    }
+    for (const order of data.items) {
+        const date = order.createdAt ? order.createdAt.split("T")[0] : "—";
+        lines.push(`#${order.orderId} [${order.code}] | ${order.status} | ${order.totalPrice} ${order.currency} | payment: ${order.paymentStatus} | ${date}`);
+    }
+    return lines.join("\n");
+}
+export function formatOrderDetail(order) {
+    const lines = [];
+    lines.push(`Order #${order.orderId} [${order.code}]`);
+    lines.push(`Status: ${order.status} | Payment: ${order.paymentStatus}`);
+    lines.push(`Total: ${order.totalPrice} ${order.currency}`);
+    if (order.ticketingDeadline) {
+        lines.push(`Ticketing deadline: ${order.ticketingDeadline}`);
+    }
+    // Passengers
+    if (order.passengers && order.passengers.length > 0) {
+        lines.push("");
+        lines.push("Passengers:");
+        for (const p of order.passengers) {
+            lines.push(`  - ${p.firstName} ${p.lastName} (${p.type}, id: ${p.id})`);
+        }
+    }
+    // Services
+    if (order.services && order.services.length > 0) {
+        lines.push("");
+        lines.push("Services:");
+        for (const s of order.services) {
+            const price = s.priceGross > 0 ? ` | ${s.priceGross}` : "";
+            const pnr = s.pnr ? ` | PNR: ${s.pnr}` : "";
+            const ticket = s.ticketNumber ? ` | Ticket: ${s.ticketNumber}` : "";
+            lines.push(`  - [${s.id}] ${s.title}`);
+            lines.push(`    ${s.status} | ${s.date}${price}${pnr}${ticket}`);
+        }
+    }
+    // Tickets
+    if (order.tickets && order.tickets.length > 0) {
+        lines.push("");
+        lines.push("Tickets:");
+        for (const t of order.tickets) {
+            lines.push(`  - ${t.ticketNumber} (service ${t.serviceId}) | ${t.status}`);
+        }
+    }
+    // Timestamps
+    lines.push("");
+    if (order.createdAt)
+        lines.push(`Created: ${order.createdAt}`);
+    if (order.updatedAt)
+        lines.push(`Updated: ${order.updatedAt}`);
+    return lines.join("\n");
+}
+export function formatCancelCheck(data, orderId) {
+    const lines = [];
+    lines.push(`Cancel check for order #${orderId}`);
+    if (!data.cancellable) {
+        lines.push(`Result: NOT cancellable`);
+        if (data.rules)
+            lines.push(`Reason: ${data.rules}`);
+        return lines.join("\n");
+    }
+    lines.push(`Result: cancellable`);
+    if (data.refund) {
+        lines.push(`Refund: ${data.refund.estimatedAmount} ${data.refund.currency} (${data.refund.type})`);
+        if (data.refund.penalty > 0) {
+            lines.push(`Penalty: ${data.refund.penalty} ${data.refund.currency}`);
+        }
+    }
+    if (data.deadline)
+        lines.push(`Deadline: ${data.deadline}`);
+    if (data.rules)
+        lines.push(`Rules: ${data.rules}`);
+    return lines.join("\n");
+}
+export function formatCancelResult(data) {
+    const lines = [];
+    lines.push(`Order #${data.orderId} — ${data.status}`);
+    if (data.cancelledAt) {
+        lines.push(`Cancelled at: ${data.cancelledAt}`);
+    }
+    if (data.refund) {
+        lines.push(`Refund: ${data.refund.amount} ${data.refund.currency} (${data.refund.type})`);
+        if (data.refund.penalty > 0) {
+            lines.push(`Penalty: ${data.refund.penalty} ${data.refund.currency}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function formatModifyCheck(data, orderId) {
+    const lines = [];
+    lines.push(`Modify check for order #${orderId}`);
+    if (!data.modifiable) {
+        lines.push(`Result: NOT modifiable`);
+        return lines.join("\n");
+    }
+    lines.push(`Result: modifiable`);
+    if (data.services && data.services.length > 0) {
+        lines.push("");
+        for (const s of data.services) {
+            lines.push(`Service ${s.serviceId}: ${s.title}`);
+            lines.push(`  Allowed changes: ${s.allowedChanges.join(", ")}`);
+        }
+    }
+    return lines.join("\n");
+}
+export function formatModifyResult(data) {
+    return `Order #${data.orderId} — ${data.status}\nUse get_order to check the result after modification completes.`;
+}
+//# sourceMappingURL=order-formatter.js.map

package/build/http-server.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * HTTP entry point for the TravelCode MCP Server.
+ *
+ * Supports OAuth 2.1 via MCP spec:
+ * - Serves Protected Resource Metadata (RFC 9728) at /.well-known/oauth-protected-resource
+ * - Returns 401 with WWW-Authenticate header when Bearer token is missing
+ * - Creates per-session McpServer instances using the user's OAuth token
+ *
+ * The Authorization Server is TravelCode's own OAuth server.
+ * Tokens are opaque and validated by TravelCode API on each request.
+ *
+ * Stdio transport (src/index.ts) remains unchanged for backward compatibility.
+ */
+export {};
+//# sourceMappingURL=http-server.d.ts.map