mcp-travelcode 1.0.0

package/build/client/api-client.js

@@ -0,0 +1,235 @@
+import { getValidToken } from "../auth/token-store.js";
+export class TravelCodeAuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TravelCodeAuthError";
+    }
+}
+export class TravelCodeNotFoundError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TravelCodeNotFoundError";
+    }
+}
+export class TravelCodeValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TravelCodeValidationError";
+    }
+}
+export class TravelCodeServerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TravelCodeServerError";
+    }
+}
+export class TravelCodeApiClient {
+    baseUrl;
+    token;
+    issuer;
+    constructor(config) {
+        this.baseUrl = config.apiBaseUrl;
+        this.token = config.apiToken;
+        this.issuer = config.oauthIssuer ?? "";
+    }
+    /**
+     * Ensures the token is still valid, refreshing via OAuth if needed.
+     * Falls back to the current token if refresh is not available.
+     */
+    async ensureValidToken() {
+        if (!this.issuer)
+            return; // static token, no refresh
+        const freshToken = await getValidToken(this.issuer);
+        if (freshToken) {
+            this.token = freshToken;
+        }
+    }
+    async get(path, params) {
+        await this.ensureValidToken();
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: this.headers(),
+        });
+        return this.handleResponse(response);
+    }
+    async post(path, body, extraHeaders) {
+        await this.ensureValidToken();
+        const headers = {
+            ...this.headers(),
+            "Content-Type": "application/json",
+            ...extraHeaders,
+        };
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+        });
+        return this.handleResponse(response);
+    }
+    async getAerodatabox(aerodataboxPath, params) {
+        await this.ensureValidToken();
+        // Build the AeroDataBox path with query params
+        const pathUrl = new URL(`https://placeholder${aerodataboxPath}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    pathUrl.searchParams.set(key, String(value));
+                }
+            }
+        }
+        const fullAeroPath = pathUrl.pathname + pathUrl.search;
+        // Proxy URL: strip /v1 from base URL, route through /flight/aerodatabox
+        const proxyBaseUrl = this.baseUrl.replace(/\/v1\/?$/, "");
+        const proxyUrl = new URL(`${proxyBaseUrl}/flight/aerodatabox`);
+        proxyUrl.searchParams.set("path", fullAeroPath);
+        const response = await fetch(proxyUrl.toString(), {
+            method: "GET",
+            headers: this.headers(),
+        });
+        return this.handleResponse(response);
+    }
+    /**
+     * POST request that returns an SSE stream.
+     * Collects events and returns them as an array of {event, data} objects.
+     */
+    async postSSE(path, body, timeoutMs = 130_000) {
+        await this.ensureValidToken();
+        // Hotels API uses accessToken in body, not Bearer header
+        const bodyWithToken = { ...body, accessToken: this.token };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-Source": "mcp-server",
+                    Accept: "text/event-stream",
+                },
+                body: JSON.stringify(bodyWithToken),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                let errorMessage;
+                try {
+                    const errorBody = (await response.json());
+                    errorMessage = errorBody.message || errorBody.text || `HTTP ${response.status}`;
+                }
+                catch {
+                    errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                }
+                if (response.status === 401)
+                    throw new TravelCodeAuthError(errorMessage);
+                if (response.status === 404)
+                    throw new TravelCodeNotFoundError(errorMessage);
+                if (response.status >= 500)
+                    throw new TravelCodeServerError(errorMessage);
+                throw new Error(`API error: ${errorMessage}`);
+            }
+            if (!response.body) {
+                throw new Error("No response body for SSE stream");
+            }
+            const events = [];
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let currentEvent = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (line.startsWith("event: ")) {
+                        currentEvent = line.slice(7).trim();
+                    }
+                    else if (line.startsWith("data: ")) {
+                        const raw = line.slice(6);
+                        try {
+                            const data = JSON.parse(raw);
+                            events.push({ event: currentEvent, data });
+                            // Stop reading after terminal events
+                            if (currentEvent === "completed" || currentEvent === "error" || currentEvent === "timeout") {
+                                reader.cancel();
+                                return events;
+                            }
+                        }
+                        catch {
+                            // skip malformed JSON lines
+                        }
+                    }
+                }
+            }
+            return events;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * GET with accessToken as query parameter (used by hotel location endpoints).
+     */
+    async getWithTokenParam(path, params) {
+        await this.ensureValidToken();
+        const allParams = { ...params, accessToken: this.token };
+        const url = new URL(`${this.baseUrl}${path}`);
+        for (const [key, value] of Object.entries(allParams)) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "X-Source": "mcp-server",
+                Accept: "application/json",
+            },
+        });
+        return this.handleResponse(response);
+    }
+    headers() {
+        return {
+            Authorization: `Bearer ${this.token}`,
+            "X-Source": "mcp-server",
+            Accept: "application/json",
+        };
+    }
+    async handleResponse(response) {
+        if (response.ok) {
+            return (await response.json());
+        }
+        let errorMessage;
+        try {
+            const errorBody = (await response.json());
+            errorMessage = errorBody.message || errorBody.text || `HTTP ${response.status}`;
+        }
+        catch {
+            errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+        }
+        switch (response.status) {
+            case 400:
+            case 422:
+                throw new TravelCodeValidationError(errorMessage);
+            case 401:
+                throw new TravelCodeAuthError(errorMessage);
+            case 404:
+                throw new TravelCodeNotFoundError(errorMessage);
+            default:
+                if (response.status >= 500) {
+                    throw new TravelCodeServerError(errorMessage);
+                }
+                throw new Error(`API error: ${errorMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=api-client.js.map

package/build/client/types.d.ts

@@ -0,0 +1,420 @@
+export interface AirportCountry {
+    title: string;
+    titleEn: string;
+    code: string;
+}
+export interface AirportCity {
+    code: string;
+    title: string;
+    titleEn: string;
+}
+export interface Airport {
+    id: string | number;
+    code: string;
+    title: string;
+    titleEn: string;
+    country?: AirportCountry;
+    city?: AirportCity;
+    isAirport?: boolean;
+    sort?: number;
+}
+export interface Airline {
+    id: number;
+    code: string;
+    title: string;
+}
+export interface FlightSearchRequest {
+    locationFrom: string;
+    locationTo: string;
+    date: string;
+    dateEnd?: string;
+    cabinClass: string;
+    adults: number;
+    children: number;
+    infants: number;
+    airlines?: string[];
+}
+export interface FlightSearchCreateResponse {
+    status: string;
+    errors: string[];
+    warnings: string[];
+    cacheId: string;
+    countServices: number;
+    countFinishedServices: number;
+    countFailedServices: number;
+    count: number;
+    completed: boolean;
+}
+export interface FlightSegmentEndpoint {
+    iata_code: string;
+    at: string;
+    terminal: string;
+    airport: {
+        iata_code: string;
+        title: string;
+    };
+}
+export interface FlightSegment {
+    departure: FlightSegmentEndpoint;
+    arrival: FlightSegmentEndpoint;
+    carrier_code: string;
+    number: string;
+    duration: string;
+    cabin: string;
+}
+export interface FlightItinerary {
+    duration: string;
+    segments: FlightSegment[];
+    transfers: number;
+}
+export interface FlightPrice {
+    currency: string;
+    totalPrice: number;
+    inclusivePrice: number;
+    exclusivePrice: number;
+}
+export interface FlightOfferItem {
+    service: string;
+    type: string;
+    availableSeats: number;
+    cabinClass: string;
+    airline: string;
+    includeBaggage: boolean;
+    include_baggage?: {
+        count: number;
+        unit: string;
+    };
+    price: FlightPrice;
+    itineraries: FlightItinerary[];
+    id: number;
+}
+export interface FlightOffer {
+    totalPrice: number;
+    totalPriceNet: number;
+    durationTime: string;
+    items: FlightOfferItem[];
+}
+export interface DictionaryAirport {
+    title: string;
+    titleEn: string;
+    city?: {
+        code: string;
+        title: string;
+        titleEn: string;
+    };
+    country?: {
+        code: string;
+        title: string;
+        titleEn: string;
+    };
+}
+export interface FlightSearchResultsResponse {
+    status: string;
+    cacheId: string;
+    items: FlightOffer[];
+    total: number;
+    limit: number;
+    offset: number;
+    currency: string;
+    currencySign: string;
+    completed?: boolean;
+    countServices?: number;
+    countFinishedServices?: number;
+    countFailedServices?: number;
+    count?: number;
+    airlines?: Record<string, string>;
+    filters?: string[];
+    dictionaries?: {
+        airports?: Record<string, DictionaryAirport>;
+    };
+}
+export interface AeroFlightTime {
+    utc?: string;
+    local?: string;
+}
+export interface AeroFlightEndpoint {
+    airport?: {
+        icao?: string;
+        iata?: string;
+        name?: string;
+        shortName?: string;
+        municipalityName?: string;
+        location?: {
+            lat?: number;
+            lon?: number;
+        };
+        countryCode?: string;
+    };
+    scheduledTime?: AeroFlightTime;
+    revisedTime?: AeroFlightTime;
+    predictedTime?: AeroFlightTime;
+    actualTime?: AeroFlightTime;
+    terminal?: string;
+    gate?: string;
+    baggageBelt?: string;
+    checkInDesk?: string;
+    quality?: string[];
+}
+export interface AeroFlightAircraft {
+    reg?: string;
+    modeS?: string;
+    model?: string;
+    image?: {
+        url?: string;
+        webUrl?: string;
+        author?: string;
+        title?: string;
+        description?: string;
+    };
+}
+export interface AeroFlightStatus {
+    type?: string;
+    status?: string;
+    departure: AeroFlightEndpoint;
+    arrival: AeroFlightEndpoint;
+    number?: string;
+    callSign?: string;
+    airline?: {
+        name?: string;
+        iata?: string;
+        icao?: string;
+    };
+    aircraft?: AeroFlightAircraft;
+    location?: {
+        pressureAltFt?: number;
+        gsKt?: number;
+        lat?: number;
+        lon?: number;
+    };
+    codeshareStatus?: string;
+    isCargo?: boolean;
+    greatCircleDistance?: {
+        meter?: number;
+        km?: number;
+        mile?: number;
+    };
+}
+export type AeroFlightStatusResponse = AeroFlightStatus[];
+export interface AeroBoardFlight {
+    departure: AeroFlightEndpoint;
+    arrival: AeroFlightEndpoint;
+    number?: string;
+    status?: string;
+    codeshareStatus?: string;
+    isCargo?: boolean;
+    airline?: {
+        name?: string;
+        iata?: string;
+        icao?: string;
+    };
+    aircraft?: {
+        model?: string;
+        reg?: string;
+    };
+}
+export interface AeroAirportBoardResponse {
+    departures?: AeroBoardFlight[];
+    arrivals?: AeroBoardFlight[];
+}
+export interface AeroFlightDelayStats {
+    route?: {
+        from?: string;
+        to?: string;
+    };
+    averageDelayMin?: number;
+    cancelledPercentage?: number;
+    delayDistribution?: Array<{
+        bucket?: string;
+        percentage?: number;
+    }>;
+    medianDelayMin?: number;
+    onTimePercentage?: number;
+    observations?: number;
+}
+export interface AeroAirportDelayInfo {
+    averageDelayMin?: number;
+    delayIndex?: number;
+    medianDelayMin?: number;
+    cancellations?: number;
+    totalFlights?: number;
+}
+export interface AeroAirportDelayStats {
+    airport?: {
+        iata?: string;
+        name?: string;
+    };
+    date?: string;
+    departures?: AeroAirportDelayInfo;
+    arrivals?: AeroAirportDelayInfo;
+}
+export interface OrderShort {
+    orderId: number;
+    code: string;
+    status: string;
+    totalPrice: number;
+    currency: string;
+    paymentStatus: string;
+    createdAt: string | null;
+}
+export interface OrderList {
+    items: OrderShort[];
+    total: number;
+    offset: number;
+    limit: number;
+}
+export interface OrderPassenger {
+    id: number;
+    firstName: string;
+    lastName: string;
+    type: string;
+}
+export interface OrderService {
+    id: number;
+    type: string;
+    title: string;
+    status: string;
+    date: string;
+    priceGross: number;
+    priceNet: number;
+    ticketNumber?: string;
+    pnr?: string;
+}
+export interface OrderTicket {
+    ticketNumber: string;
+    serviceId: number;
+    type: string;
+    status: string;
+}
+export interface OrderFull {
+    orderId: number;
+    code: string;
+    status: string;
+    totalPrice: number;
+    currency: string;
+    passengers: OrderPassenger[];
+    services: OrderService[];
+    tickets?: OrderTicket[];
+    paymentStatus: string;
+    ticketingDeadline: string | null;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+export interface CancelCheckRefund {
+    estimatedAmount: number;
+    penalty: number;
+    currency: string;
+    type: string;
+}
+export interface CancelCheckResponse {
+    cancellable: boolean;
+    refund?: CancelCheckRefund | null;
+    deadline?: string | null;
+    rules?: string | null;
+}
+export interface CancelResultRefund {
+    amount: number;
+    currency: string;
+    type: string;
+    penalty: number;
+}
+export interface CancelResult {
+    orderId: number;
+    status: string;
+    cancelledAt: string | null;
+    refund?: CancelResultRefund | null;
+}
+export interface ModifyCheckService {
+    serviceId: number;
+    title: string;
+    allowedChanges: string[];
+}
+export interface ModifyCheckResponse {
+    modifiable: boolean;
+    services?: ModifyCheckService[];
+}
+export interface ModifyResult {
+    orderId: number;
+    status: string;
+}
+export interface HotelLocationChild {
+    id: string | number;
+    partner: string;
+    name: string;
+    address: string;
+    countryCode: string;
+}
+export interface HotelLocationGroup {
+    type: string;
+    text: string;
+    children: HotelLocationChild[];
+}
+export interface HotelLocationSearchResponse {
+    items: HotelLocationGroup[];
+    time: number;
+}
+export interface HotelLocationDetail {
+    id: number;
+    nameRu: string;
+    nameEn: string;
+    entityType: string;
+}
+export interface HotelLocationDetailResponse {
+    result: HotelLocationDetail;
+}
+export interface HotelRoomGuests {
+    adults: number;
+    children?: number;
+    childrenAges?: number[];
+}
+export interface HotelSearchFilter {
+    minPrice?: number;
+    maxPrice?: number;
+    starRating?: number[];
+    boards?: string[];
+    payments?: string[];
+}
+export interface HotelOffer {
+    id?: number;
+    name?: string;
+    stars?: number;
+    address?: string;
+    image?: string;
+    price?: number;
+    currency?: string;
+    board?: string;
+    boardName?: string;
+    rooms?: number;
+    cancellation?: string;
+    [key: string]: unknown;
+}
+export interface HotelSSEConnected {
+    status: string;
+    cached?: boolean;
+}
+export interface HotelSSEHotelsBatch {
+    batch: number;
+    count: number;
+    hotels: HotelOffer[];
+}
+export interface HotelSSESortedBatch {
+    count: number;
+    total: number;
+    chunk: number;
+    hotels: HotelOffer[];
+}
+export interface HotelSSECount {
+    batch: number;
+    count: number;
+    total: number;
+}
+export interface HotelSSECompleted {
+    count: number;
+    hotels: HotelOffer[];
+    cacheKey: string;
+}
+export interface ApiErrorResponse {
+    code: number;
+    message?: string;
+    text?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/client/types.js

@@ -0,0 +1,3 @@
+// --- Airports ---
+export {};
+//# sourceMappingURL=types.js.map

package/build/config.d.ts

@@ -0,0 +1,9 @@
+export interface TravelCodeConfig {
+    apiBaseUrl: string;
+    apiToken: string;
+    oauthIssuer?: string;
+    pollIntervalMs: number;
+    pollTimeoutMs: number;
+}
+export declare function loadConfig(): Promise<TravelCodeConfig>;
+//# sourceMappingURL=config.d.ts.map

package/build/config.js

@@ -0,0 +1,30 @@
+import { getValidToken } from "./auth/token-store.js";
+const DEFAULT_ISSUER = "https://travel-code.com";
+export async function loadConfig() {
+    const apiBaseUrl = process.env.TRAVELCODE_API_BASE_URL || "https://api.travel-code.com/v1";
+    const issuer = process.env.OAUTH_ISSUER || DEFAULT_ISSUER;
+    // 1. Try env variable first (backward compat)
+    let apiToken = process.env.TRAVELCODE_API_TOKEN;
+    let oauthIssuer;
+    // 2. Try saved OAuth tokens
+    if (!apiToken) {
+        const savedToken = await getValidToken(issuer);
+        if (savedToken) {
+            apiToken = savedToken;
+            oauthIssuer = issuer; // enable auto-refresh in ApiClient
+        }
+    }
+    if (!apiToken) {
+        throw new Error("No API token available.\n" +
+            "  Option 1: Run 'npx mcp-travelcode auth' to authenticate via OAuth\n" +
+            "  Option 2: Set TRAVELCODE_API_TOKEN environment variable");
+    }
+    return {
+        apiBaseUrl: apiBaseUrl.replace(/\/+$/, ""),
+        apiToken,
+        oauthIssuer,
+        pollIntervalMs: parseInt(process.env.TRAVELCODE_POLL_INTERVAL_MS || "2000", 10),
+        pollTimeoutMs: parseInt(process.env.TRAVELCODE_POLL_TIMEOUT_MS || "90000", 10),
+    };
+}
+//# sourceMappingURL=config.js.map

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

@@ -0,0 +1,6 @@
+import { AeroFlightStatus, AeroBoardFlight, AeroFlightDelayStats, AeroAirportDelayStats } from "../client/types.js";
+export declare function formatFlightStatus(flights: AeroFlightStatus[], flightNumber: string, date: string): string;
+export declare function formatAirportBoard(flights: AeroBoardFlight[], airportCode: string, direction: string, fromTime: string, toTime: string): string;
+export declare function formatFlightDelayStats(stats: AeroFlightDelayStats, flightNumber: string): string;
+export declare function formatAirportDelayStats(stats: AeroAirportDelayStats, airportCode: string, date: string): string;
+//# sourceMappingURL=aerodatabox-formatter.d.ts.map