@striderlabs/mcp-zipcar 1.0.0

package/src/index.ts

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Tool,
+} from "@modelcontextprotocol/sdk/types.js";
+import { chromium, Browser, BrowserContext, Page } from "patchright";
+
+// --- Types ---
+
+interface SearchCarsArgs {
+  location: string;
+  start_time: string;
+  end_time: string;
+  radius_miles?: number;
+}
+
+interface GetCarDetailsArgs {
+  car_id: string;
+}
+
+interface ReserveCarArgs {
+  car_id: string;
+  start_time: string;
+  end_time: string;
+  plan?: string;
+}
+
+interface ExtendReservationArgs {
+  reservation_id: string;
+  new_end_time: string;
+}
+
+interface EndTripArgs {
+  reservation_id: string;
+}
+
+interface GetReservationHistoryArgs {
+  filter?: "upcoming" | "past" | "all";
+  limit?: number;
+}
+
+// --- Browser session management ---
+
+let browser: Browser | null = null;
+let context: BrowserContext | null = null;
+
+async function getBrowser(): Promise<Browser> {
+  if (!browser || !browser.isConnected()) {
+    browser = await chromium.launch({
+      headless: true,
+      args: [
+        "--no-sandbox",
+        "--disable-blink-features=AutomationControlled",
+      ],
+    });
+  }
+  return browser;
+}
+
+async function getContext(): Promise<BrowserContext> {
+  if (!context) {
+    const b = await getBrowser();
+    context = await b.newContext({
+      userAgent:
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      viewport: { width: 1280, height: 800 },
+      locale: "en-US",
+    });
+  }
+  return context;
+}
+
+async function newPage(): Promise<Page> {
+  const ctx = await getContext();
+  return ctx.newPage();
+}
+
+// --- Tool implementations ---
+
+async function searchCars(args: SearchCarsArgs): Promise<string> {
+  const page = await newPage();
+  try {
+    const url = `https://www.zipcar.com/cars?location=${encodeURIComponent(args.location)}&starttime=${encodeURIComponent(args.start_time)}&endtime=${encodeURIComponent(args.end_time)}`;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+
+    // Wait for car listings to appear
+    await page.waitForSelector('[data-testid="car-card"], .vehicle-card, .car-listing', {
+      timeout: 15000,
+    }).catch(() => null);
+
+    const cars = await page.evaluate(() => {
+      const results: Array<{
+        id: string;
+        name: string;
+        type: string;
+        location: string;
+        distance: string;
+        hourly_rate: string;
+        daily_rate: string;
+        available: boolean;
+      }> = [];
+
+      // Try multiple selectors for different page structures
+      const cardSelectors = [
+        '[data-testid="car-card"]',
+        ".vehicle-card",
+        ".car-listing",
+        "[class*='VehicleCard']",
+        "[class*='CarCard']",
+      ];
+
+      let cards: NodeListOf<Element> | null = null;
+      for (const sel of cardSelectors) {
+        const found = document.querySelectorAll(sel);
+        if (found.length > 0) {
+          cards = found;
+          break;
+        }
+      }
+
+      if (!cards) return results;
+
+      cards.forEach((card, index) => {
+        const nameEl =
+          card.querySelector("[class*='name'], [class*='Name'], h2, h3") as HTMLElement | null;
+        const typeEl =
+          card.querySelector("[class*='type'], [class*='Type'], [class*='category']") as HTMLElement | null;
+        const locationEl =
+          card.querySelector("[class*='location'], [class*='Location'], [class*='address']") as HTMLElement | null;
+        const distEl =
+          card.querySelector("[class*='distance'], [class*='Distance']") as HTMLElement | null;
+        const hourlyEl =
+          card.querySelector("[class*='hourly'], [class*='Hourly'], [class*='rate']") as HTMLElement | null;
+        const dailyEl =
+          card.querySelector("[class*='daily'], [class*='Daily']") as HTMLElement | null;
+
+        const idAttr =
+          (card as HTMLElement).dataset.vehicleId ||
+          (card as HTMLElement).dataset.carId ||
+          (card as HTMLElement).dataset.id ||
+          `car-${index}`;
+
+        results.push({
+          id: idAttr,
+          name: nameEl?.innerText?.trim() || "Unknown Vehicle",
+          type: typeEl?.innerText?.trim() || "Car",
+          location: locationEl?.innerText?.trim() || "See map",
+          distance: distEl?.innerText?.trim() || "N/A",
+          hourly_rate: hourlyEl?.innerText?.trim() || "N/A",
+          daily_rate: dailyEl?.innerText?.trim() || "N/A",
+          available: !card.classList.contains("unavailable"),
+        });
+      });
+
+      return results;
+    });
+
+    if (cars.length === 0) {
+      return JSON.stringify({
+        status: "no_results",
+        message: `No available Zipcars found near "${args.location}" for the requested time period.`,
+        searched_url: url,
+      });
+    }
+
+    return JSON.stringify({
+      status: "success",
+      location: args.location,
+      start_time: args.start_time,
+      end_time: args.end_time,
+      total_found: cars.length,
+      cars,
+    });
+  } finally {
+    await page.close();
+  }
+}
+
+async function getCarDetails(args: GetCarDetailsArgs): Promise<string> {
+  const page = await newPage();
+  try {
+    const url = `https://www.zipcar.com/cars/${encodeURIComponent(args.car_id)}`;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+
+    await page.waitForSelector(
+      "[class*='VehicleDetail'], [class*='CarDetail'], .vehicle-detail, main",
+      { timeout: 15000 }
+    ).catch(() => null);
+
+    const details = await page.evaluate((carId: string) => {
+      const getText = (selector: string): string =>
+        (document.querySelector(selector) as HTMLElement | null)?.innerText?.trim() || "N/A";
+
+      const features: string[] = [];
+      document.querySelectorAll("[class*='feature'], [class*='Feature'], [class*='amenity']").forEach((el) => {
+        const text = (el as HTMLElement).innerText?.trim();
+        if (text) features.push(text);
+      });
+
+      return {
+        car_id: carId,
+        name: getText("h1, [class*='VehicleName'], [class*='CarName']"),
+        type:
+          getText("[class*='vehicleType'], [class*='VehicleType'], [class*='category']"),
+        year: getText("[class*='year'], [class*='Year']"),
+        make: getText("[class*='make'], [class*='Make']"),
+        model: getText("[class*='model'], [class*='Model']"),
+        seats: getText("[class*='seats'], [class*='Seats'], [class*='capacity']"),
+        fuel_type: getText("[class*='fuel'], [class*='Fuel']"),
+        transmission: getText("[class*='transmission'], [class*='Transmission']"),
+        hourly_rate: getText("[class*='hourly'], [class*='HourlyRate']"),
+        daily_rate: getText("[class*='daily'], [class*='DailyRate']"),
+        included_miles_per_hour: getText("[class*='miles'], [class*='Miles']"),
+        location: getText("[class*='location'], [class*='Location'], [class*='address']"),
+        features: features.slice(0, 20),
+      };
+    }, args.car_id);
+
+    return JSON.stringify({ status: "success", details });
+  } finally {
+    await page.close();
+  }
+}
+
+async function reserveCar(args: ReserveCarArgs): Promise<string> {
+  const page = await newPage();
+  try {
+    // Navigate to the car's booking page
+    const url = `https://www.zipcar.com/cars/${encodeURIComponent(args.car_id)}/reserve`;
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+
+    // Check if user is logged in
+    const isLoggedIn = await page.evaluate(() => {
+      return (
+        !document.querySelector("[class*='SignIn'], [class*='Login'], [href*='login']") ||
+        !!document.querySelector("[class*='UserMenu'], [class*='AccountMenu'], [data-testid='user-menu']")
+      );
+    });
+
+    if (!isLoggedIn) {
+      return JSON.stringify({
+        status: "auth_required",
+        message:
+          "Authentication required. Please log in to Zipcar before making a reservation.",
+        action: "Please use a browser to log in to zipcar.com, then retry.",
+      });
+    }
+
+    // Fill in start time
+    const startInput = await page.$("[name='startTime'], [data-testid='start-time'], #start-time");
+    if (startInput) {
+      await startInput.fill(args.start_time);
+    }
+
+    // Fill in end time
+    const endInput = await page.$("[name='endTime'], [data-testid='end-time'], #end-time");
+    if (endInput) {
+      await endInput.fill(args.end_time);
+    }
+
+    // Select plan if specified
+    if (args.plan) {
+      const planSelector = await page.$(`[data-plan="${args.plan}"], [value="${args.plan}"]`);
+      if (planSelector) {
+        await planSelector.click();
+      }
+    }
+
+    // Get reservation summary before confirming
+    const summary = await page.evaluate(() => {
+      const getText = (sel: string) =>
+        (document.querySelector(sel) as HTMLElement | null)?.innerText?.trim() || "N/A";
+      return {
+        subtotal: getText("[class*='subtotal'], [class*='Subtotal']"),
+        total: getText("[class*='total'], [class*='Total']"),
+        duration: getText("[class*='duration'], [class*='Duration']"),
+        included_miles: getText("[class*='includedMiles'], [class*='miles']"),
+      };
+    });
+
+    // Click confirm/reserve button
+    const confirmBtn = await page.$(
+      "[data-testid='confirm-reservation'], [class*='ConfirmButton'], button[type='submit']"
+    );
+    if (confirmBtn) {
+      await confirmBtn.click();
+      await page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => null);
+    }
+
+    // Extract confirmation details
+    const confirmation = await page.evaluate(() => {
+      const getText = (sel: string) =>
+        (document.querySelector(sel) as HTMLElement | null)?.innerText?.trim() || "N/A";
+      return {
+        reservation_id: getText("[class*='confirmationNumber'], [data-testid='reservation-id']"),
+        status: getText("[class*='status'], [class*='Status']"),
+        message: getText("[class*='confirmationMessage'], [class*='success']"),
+      };
+    });
+
+    return JSON.stringify({
+      status: "success",
+      reservation: {
+        car_id: args.car_id,
+        start_time: args.start_time,
+        end_time: args.end_time,
+        plan: args.plan || "default",
+        ...confirmation,
+        cost_summary: summary,
+      },
+    });
+  } finally {
+    await page.close();
+  }
+}
+
+async function extendReservation(args: ExtendReservationArgs): Promise<string> {
+  const page = await newPage();
+  try {
+    await page.goto("https://www.zipcar.com/my-zipcar/reservations", {
+      waitUntil: "domcontentloaded",
+      timeout: 30000,
+    });
+
+    // Find the reservation
+    const reservationSelector = `[data-reservation-id="${args.reservation_id}"], [data-id="${args.reservation_id}"]`;
+    await page.waitForSelector(reservationSelector, { timeout: 10000 }).catch(() => null);
+
+    // Click extend/modify button
+    const extendBtn = await page.$(
+      `${reservationSelector} [class*='extend'], ${reservationSelector} [data-action='extend']`
+    );
+    if (!extendBtn) {
+      // Try finding extend button generically for the active reservation
+      const anyExtend = await page.$("[class*='ExtendTrip'], [data-testid='extend-trip'], button:has-text('Extend')");
+      if (anyExtend) await anyExtend.click();
+    } else {
+      await extendBtn.click();
+    }
+
+    // Set new end time
+    await page.waitForSelector("[name='newEndTime'], [data-testid='new-end-time']", { timeout: 10000 }).catch(() => null);
+    const newEndInput = await page.$("[name='newEndTime'], [data-testid='new-end-time'], #new-end-time");
+    if (newEndInput) {
+      await newEndInput.fill(args.new_end_time);
+    }
+
+    // Confirm extension
+    const confirmBtn = await page.$(
+      "[data-testid='confirm-extend'], button[type='submit'], [class*='ConfirmExtend']"
+    );
+    if (confirmBtn) {
+      await confirmBtn.click();
+      await page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => null);
+    }
+
+    const result = await page.evaluate(() => {
+      const getText = (sel: string) =>
+        (document.querySelector(sel) as HTMLElement | null)?.innerText?.trim() || "N/A";
+      return {
+        confirmation: getText("[class*='confirmation'], [class*='success']"),
+        confirmed_end_time: getText("[class*='endTime'], [class*='EndTime']"),
+        additional_cost: getText("[class*='additionalCost'], [class*='cost']"),
+      };
+    });
+
+    return JSON.stringify({
+      status: "success",
+      reservation_id: args.reservation_id,
+      new_end_time: args.new_end_time,
+      ...result,
+    });
+  } finally {
+    await page.close();
+  }
+}
+
+async function endTrip(args: EndTripArgs): Promise<string> {
+  const page = await newPage();
+  try {
+    await page.goto("https://www.zipcar.com/my-zipcar/active-trip", {
+      waitUntil: "domcontentloaded",
+      timeout: 30000,
+    });
+
+    // Find end trip button
+    await page.waitForSelector(
+      "[data-testid='end-trip'], [class*='EndTrip'], button:has-text('End Trip')",
+      { timeout: 15000 }
+    ).catch(() => null);
+
+    const endTripBtn = await page.$(
+      "[data-testid='end-trip'], [class*='EndTripButton'], button[data-action='end-trip']"
+    );
+
+    if (!endTripBtn) {
+      return JSON.stringify({
+        status: "error",
+        message: "Could not find active trip controls. Make sure you have an active reservation.",
+        reservation_id: args.reservation_id,
+      });
+    }
+
+    await endTripBtn.click();
+
+    // Handle confirmation dialog
+    await page.waitForSelector("[data-testid='confirm-end-trip'], [class*='ConfirmDialog']", {
+      timeout: 5000,
+    }).catch(() => null);
+
+    const confirmDialog = await page.$("[data-testid='confirm-end-trip'], [class*='ConfirmEnd']");
+    if (confirmDialog) {
+      await confirmDialog.click();
+      await page.waitForNavigation({ waitUntil: "domcontentloaded", timeout: 15000 }).catch(() => null);
+    }
+
+    const tripSummary = await page.evaluate(() => {
+      const getText = (sel: string) =>
+        (document.querySelector(sel) as HTMLElement | null)?.innerText?.trim() || "N/A";
+      return {
+        end_time: getText("[class*='endTime'], [class*='tripEnd']"),
+        duration: getText("[class*='tripDuration'], [class*='duration']"),
+        miles_driven: getText("[class*='milesDriven'], [class*='miles']"),
+        total_cost: getText("[class*='totalCost'], [class*='total']"),
+        receipt_url: (document.querySelector("[href*='receipt']") as HTMLAnchorElement | null)?.href || "N/A",
+      };
+    });
+
+    return JSON.stringify({
+      status: "success",
+      reservation_id: args.reservation_id,
+      trip_summary: tripSummary,
+    });
+  } finally {
+    await page.close();
+  }
+}
+
+async function getReservationHistory(args: GetReservationHistoryArgs): Promise<string> {
+  const page = await newPage();
+  try {
+    await page.goto("https://www.zipcar.com/my-zipcar/reservations", {
+      waitUntil: "domcontentloaded",
+      timeout: 30000,
+    });
+
+    await page.waitForSelector(
+      "[class*='ReservationList'], [class*='reservation-list'], [data-testid='reservations']",
+      { timeout: 15000 }
+    ).catch(() => null);
+
+    const filter = args.filter || "all";
+    const limit = args.limit || 20;
+
+    // Click appropriate filter tab
+    if (filter !== "all") {
+      const tabSelector = `[data-tab="${filter}"], button:has-text("${filter === "upcoming" ? "Upcoming" : "Past"}")`;
+      const tab = await page.$(tabSelector);
+      if (tab) {
+        await tab.click();
+        await page.waitForTimeout(1000);
+      }
+    }
+
+    const reservations = await page.evaluate((maxItems: number) => {
+      const results: Array<{
+        id: string;
+        car_name: string;
+        car_type: string;
+        pickup_location: string;
+        start_time: string;
+        end_time: string;
+        status: string;
+        total_cost: string;
+        miles_driven: string;
+      }> = [];
+
+      const cardSelectors = [
+        "[class*='ReservationCard']",
+        "[class*='reservation-card']",
+        "[data-testid='reservation-item']",
+        "li[class*='reservation']",
+      ];
+
+      let cards: NodeListOf<Element> | null = null;
+      for (const sel of cardSelectors) {
+        const found = document.querySelectorAll(sel);
+        if (found.length > 0) {
+          cards = found;
+          break;
+        }
+      }
+
+      if (!cards) return results;
+
+      const count = Math.min(cards.length, maxItems);
+      for (let i = 0; i < count; i++) {
+        const card = cards[i];
+        const getText = (sel: string) =>
+          (card.querySelector(sel) as HTMLElement | null)?.innerText?.trim() || "N/A";
+
+        results.push({
+          id:
+            (card as HTMLElement).dataset.reservationId ||
+            (card as HTMLElement).dataset.id ||
+            `res-${i}`,
+          car_name: getText("[class*='carName'], [class*='vehicleName'], h3, h4"),
+          car_type: getText("[class*='carType'], [class*='vehicleType']"),
+          pickup_location: getText("[class*='location'], [class*='pickupLocation']"),
+          start_time: getText("[class*='startTime'], [class*='pickupTime'], [data-label='Start']"),
+          end_time: getText("[class*='endTime'], [class*='returnTime'], [data-label='End']"),
+          status: getText("[class*='status'], [class*='reservationStatus']"),
+          total_cost: getText("[class*='totalCost'], [class*='cost'], [class*='price']"),
+          miles_driven: getText("[class*='milesDriven'], [class*='miles']"),
+        });
+      }
+
+      return results;
+    }, limit);
+
+    return JSON.stringify({
+      status: "success",
+      filter,
+      total_returned: reservations.length,
+      reservations,
+    });
+  } finally {
+    await page.close();
+  }
+}
+
+// --- Tool definitions ---
+
+const TOOLS: Tool[] = [
+  {
+    name: "search_cars",
+    description:
+      "Search for available Zipcars near a location for a given time period. Returns a list of available vehicles with rates and locations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        location: {
+          type: "string",
+          description: "Address, city, or zip code to search near (e.g. '10001', 'Brooklyn, NY', '123 Main St, Boston')",
+        },
+        start_time: {
+          type: "string",
+          description: "Reservation start time in ISO 8601 format (e.g. '2025-08-15T10:00:00')",
+        },
+        end_time: {
+          type: "string",
+          description: "Reservation end time in ISO 8601 format (e.g. '2025-08-15T14:00:00')",
+        },
+        radius_miles: {
+          type: "number",
+          description: "Search radius in miles (default: 1)",
+        },
+      },
+      required: ["location", "start_time", "end_time"],
+    },
+  },
+  {
+    name: "get_car_details",
+    description:
+      "Get detailed information about a specific Zipcar including vehicle type, features, seating, fuel type, and pricing rates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        car_id: {
+          type: "string",
+          description: "The Zipcar vehicle ID from search results",
+        },
+      },
+      required: ["car_id"],
+    },
+  },
+  {
+    name: "reserve_car",
+    description:
+      "Book a Zipcar for a specific time slot. Requires the user to be logged in to Zipcar. Returns reservation confirmation details.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        car_id: {
+          type: "string",
+          description: "The Zipcar vehicle ID to reserve",
+        },
+        start_time: {
+          type: "string",
+          description: "Reservation start time in ISO 8601 format",
+        },
+        end_time: {
+          type: "string",
+          description: "Reservation end time in ISO 8601 format",
+        },
+        plan: {
+          type: "string",
+          description: "Optional membership plan to use (e.g. 'hourly', 'daily')",
+        },
+      },
+      required: ["car_id", "start_time", "end_time"],
+    },
+  },
+  {
+    name: "extend_reservation",
+    description:
+      "Extend an existing Zipcar reservation to a later end time. The car must still be available for the extended period.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        reservation_id: {
+          type: "string",
+          description: "The reservation ID to extend",
+        },
+        new_end_time: {
+          type: "string",
+          description: "The new end time in ISO 8601 format",
+        },
+      },
+      required: ["reservation_id", "new_end_time"],
+    },
+  },
+  {
+    name: "end_trip",
+    description:
+      "End an active Zipcar rental session. The car must be parked at a valid Zipcar spot. Returns a trip summary with duration, miles, and cost.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        reservation_id: {
+          type: "string",
+          description: "The active reservation ID to end",
+        },
+      },
+      required: ["reservation_id"],
+    },
+  },
+  {
+    name: "get_reservation_history",
+    description:
+      "View past and upcoming Zipcar reservations. Can filter by upcoming or past reservations.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filter: {
+          type: "string",
+          enum: ["upcoming", "past", "all"],
+          description: "Filter reservations: 'upcoming', 'past', or 'all' (default: 'all')",
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of reservations to return (default: 20)",
+        },
+      },
+      required: [],
+    },
+  },
+];
+
+// --- MCP Server setup ---
+
+const server = new Server(
+  {
+    name: "mcp-zipcar",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result: string;
+
+    switch (name) {
+      case "search_cars":
+        result = await searchCars(args as unknown as SearchCarsArgs);
+        break;
+      case "get_car_details":
+        result = await getCarDetails(args as unknown as GetCarDetailsArgs);
+        break;
+      case "reserve_car":
+        result = await reserveCar(args as unknown as ReserveCarArgs);
+        break;
+      case "extend_reservation":
+        result = await extendReservation(args as unknown as ExtendReservationArgs);
+        break;
+      case "end_trip":
+        result = await endTrip(args as unknown as EndTripArgs);
+        break;
+      case "get_reservation_history":
+        result = await getReservationHistory(args as unknown as GetReservationHistoryArgs);
+        break;
+      default:
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true,
+        };
+    }
+
+    return {
+      content: [{ type: "text", text: result }],
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ status: "error", error: message }),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Cleanup on exit
+process.on("exit", async () => {
+  if (context) await context.close().catch(() => null);
+  if (browser) await browser.close().catch(() => null);
+});
+
+process.on("SIGINT", async () => {
+  if (context) await context.close().catch(() => null);
+  if (browser) await browser.close().catch(() => null);
+  process.exit(0);
+});
+
+// Start server
+const transport = new StdioServerTransport();
+await server.connect(transport);