@striderlabs/mcp-opentable 0.1.0

package/README.md

@@ -0,0 +1,226 @@
+# @striderlabs/mcp-opentable
+
+[![npm](https://img.shields.io/npm/v/@striderlabs/mcp-opentable)](https://www.npmjs.com/package/@striderlabs/mcp-opentable)
+[![MCP Registry](https://img.shields.io/badge/MCP-Registry-blue)](https://registry.modelcontextprotocol.io/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+MCP server for OpenTable — let AI agents search restaurants and book reservations.
+
+Built by [Strider Labs](https://striderlabs.ai).
+
+## Features
+
+- Search restaurants by location, cuisine, party size, date and time
+- Get detailed restaurant info — description, address, hours, and features
+- Check real-time availability for any date, time, and party size
+- Book reservations with a confirmation step before committing
+- View all upcoming reservations in one place
+- Cancel reservations safely with a confirm gate
+- Persistent sessions — stay logged in across restarts
+
+## Installation
+
+```bash
+npm install -g @striderlabs/mcp-opentable
+```
+
+Or with npx:
+
+```bash
+npx @striderlabs/mcp-opentable
+```
+
+## Configuration
+
+Add to your MCP client configuration (e.g., Claude Desktop `~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "opentable": {
+      "command": "npx",
+      "args": ["-y", "@striderlabs/mcp-opentable"]
+    }
+  }
+}
+```
+
+## Authentication
+
+This connector uses browser automation via Playwright. On first use:
+
+1. Call `opentable_status` — it returns a login URL
+2. Open the login URL in your browser and sign in to OpenTable
+3. Session cookies are automatically saved to `~/.strider/opentable/cookies.json`
+4. Sessions persist across restarts — no need to log in again
+
+To log out or reset your session:
+
+```
+opentable_logout
+```
+
+## Available Tools
+
+### Session Management
+
+| Tool | Description |
+|------|-------------|
+| `opentable_status` | Check login status; returns login URL if not authenticated |
+| `opentable_login` | Get the OpenTable login URL and instructions |
+| `opentable_logout` | Clear stored session cookies (log out) |
+
+### Discovery
+
+| Tool | Description |
+|------|-------------|
+| `opentable_search` | Search restaurants by location, cuisine, party size, date/time |
+| `opentable_get_restaurant` | Get full details for a specific restaurant |
+| `opentable_check_availability` | List available time slots for a restaurant |
+
+### Reservations
+
+| Tool | Description |
+|------|-------------|
+| `opentable_make_reservation` | Book a reservation (requires `confirm=true`) |
+| `opentable_get_reservations` | List all upcoming reservations |
+| `opentable_cancel_reservation` | Cancel a reservation (requires `confirm=true`) |
+
+## Example Usage
+
+### Search for restaurants
+
+```json
+{
+  "tool": "opentable_search",
+  "arguments": {
+    "location": "San Francisco",
+    "cuisine": "italian",
+    "partySize": 4,
+    "date": "2026-03-20",
+    "time": "19:30"
+  }
+}
+```
+
+### Check availability
+
+```json
+{
+  "tool": "opentable_check_availability",
+  "arguments": {
+    "restaurantId": "restaurant-slug-or-id",
+    "date": "2026-03-20",
+    "time": "19:30",
+    "partySize": 4
+  }
+}
+```
+
+### Book a reservation (two-step)
+
+```json
+// Step 1: Preview
+{
+  "tool": "opentable_make_reservation",
+  "arguments": {
+    "restaurantId": "restaurant-slug-or-id",
+    "date": "2026-03-20",
+    "time": "19:30",
+    "partySize": 4,
+    "specialRequests": "Window table if possible",
+    "confirm": false
+  }
+}
+
+// Step 2: Confirm and book
+{
+  "tool": "opentable_make_reservation",
+  "arguments": {
+    "restaurantId": "restaurant-slug-or-id",
+    "date": "2026-03-20",
+    "time": "19:30",
+    "partySize": 4,
+    "specialRequests": "Window table if possible",
+    "confirm": true
+  }
+}
+```
+
+### View upcoming reservations
+
+```json
+{
+  "tool": "opentable_get_reservations",
+  "arguments": {}
+}
+```
+
+### Cancel a reservation
+
+```json
+// Step 1: Preview cancellation
+{
+  "tool": "opentable_cancel_reservation",
+  "arguments": {
+    "reservationId": "res-abc123",
+    "confirm": false
+  }
+}
+
+// Step 2: Confirm cancellation
+{
+  "tool": "opentable_cancel_reservation",
+  "arguments": {
+    "reservationId": "res-abc123",
+    "confirm": true
+  }
+}
+```
+
+## Requirements
+
+- Node.js 18+
+- Playwright browsers (auto-installed on first run via `playwright install chromium`)
+
+## How It Works
+
+This connector uses Playwright for browser automation:
+
+1. **Headless Chrome** — runs a real browser in the background
+2. **Cookie persistence** — maintains logged-in state across sessions
+3. **Stealth mode** — uses realistic browser fingerprints to avoid detection
+4. **Structured responses** — all data returned as JSON
+
+## Security
+
+- Session cookies are stored locally in `~/.strider/opentable/cookies.json`
+- No credentials are stored — authentication uses browser-based login
+- Cookies are only readable by the current OS user
+
+## Limitations
+
+- OpenTable must be available in your region
+- Some reservation flows may require additional profile information on your OpenTable account
+- Bot-detection countermeasures on OpenTable's site may occasionally interrupt automation
+
+## Development
+
+```bash
+git clone https://github.com/markswendsen-code/mcp-opentable.git
+cd mcp-opentable
+npm install
+npx playwright install chromium
+npm run build
+npm start
+```
+
+## License
+
+MIT © [Strider Labs](https://striderlabs.ai)
+
+## Related
+
+- [@striderlabs/mcp-doordash](https://www.npmjs.com/package/@striderlabs/mcp-doordash) - DoorDash MCP connector
+- [@striderlabs/mcp-gmail](https://www.npmjs.com/package/@striderlabs/mcp-gmail) - Gmail MCP connector
+- [Model Context Protocol](https://modelcontextprotocol.io) - Learn more about MCP

package/dist/auth.d.ts

@@ -0,0 +1,36 @@
+/**
+ * OpenTable Authentication & Session Management
+ *
+ * Handles cookie persistence and login state detection.
+ */
+import type { BrowserContext } from "playwright";
+export interface AuthState {
+    isLoggedIn: boolean;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+}
+/**
+ * Save cookies from browser context to disk
+ */
+export declare function saveCookies(context: BrowserContext): Promise<void>;
+/**
+ * Load cookies from disk and add to browser context
+ */
+export declare function loadCookies(context: BrowserContext): Promise<boolean>;
+/**
+ * Clear stored cookies
+ */
+export declare function clearCookies(): void;
+/**
+ * Check if we have stored cookies
+ */
+export declare function hasStoredCookies(): boolean;
+/**
+ * Extract auth state from OpenTable page cookies
+ */
+export declare function getAuthState(context: BrowserContext): Promise<AuthState>;
+/**
+ * Get the path where cookies are stored
+ */
+export declare function getCookiesPath(): string;

package/dist/auth.js

@@ -0,0 +1,97 @@
+/**
+ * OpenTable Authentication & Session Management
+ *
+ * Handles cookie persistence and login state detection.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+// Cookie storage location: ~/.strider/opentable/
+const CONFIG_DIR = join(homedir(), ".strider", "opentable");
+const COOKIES_FILE = join(CONFIG_DIR, "cookies.json");
+/**
+ * Ensure config directory exists
+ */
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Save cookies from browser context to disk
+ */
+export async function saveCookies(context) {
+    ensureConfigDir();
+    const cookies = await context.cookies();
+    writeFileSync(COOKIES_FILE, JSON.stringify(cookies, null, 2));
+}
+/**
+ * Load cookies from disk and add to browser context
+ */
+export async function loadCookies(context) {
+    if (!existsSync(COOKIES_FILE)) {
+        return false;
+    }
+    try {
+        const cookiesData = readFileSync(COOKIES_FILE, "utf-8");
+        const cookies = JSON.parse(cookiesData);
+        if (cookies.length > 0) {
+            await context.addCookies(cookies);
+            return true;
+        }
+    }
+    catch (error) {
+        console.error("Failed to load cookies:", error);
+    }
+    return false;
+}
+/**
+ * Clear stored cookies
+ */
+export function clearCookies() {
+    if (existsSync(COOKIES_FILE)) {
+        writeFileSync(COOKIES_FILE, "[]");
+    }
+}
+/**
+ * Check if we have stored cookies
+ */
+export function hasStoredCookies() {
+    if (!existsSync(COOKIES_FILE)) {
+        return false;
+    }
+    try {
+        const cookiesData = readFileSync(COOKIES_FILE, "utf-8");
+        const cookies = JSON.parse(cookiesData);
+        return Array.isArray(cookies) && cookies.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract auth state from OpenTable page cookies
+ */
+export async function getAuthState(context) {
+    const cookies = await context.cookies("https://www.opentable.com");
+    // OpenTable uses various session/auth cookies
+    const sessionCookie = cookies.find((c) => c.name === "OT_SESSION" ||
+        c.name === "ot_session" ||
+        c.name === "otd" ||
+        c.name === "OTUserInfo" ||
+        c.name === "ot_userid");
+    if (sessionCookie) {
+        return {
+            isLoggedIn: true,
+        };
+    }
+    return {
+        isLoggedIn: false,
+    };
+}
+/**
+ * Get the path where cookies are stored
+ */
+export function getCookiesPath() {
+    return COOKIES_FILE;
+}

package/dist/browser.d.ts

@@ -0,0 +1,140 @@
+/**
+ * OpenTable Browser Automation
+ *
+ * Playwright-based automation for OpenTable reservation operations.
+ */
+import { AuthState } from "./auth.js";
+export interface Restaurant {
+    id: string;
+    name: string;
+    cuisine: string;
+    location: string;
+    neighborhood?: string;
+    rating?: number;
+    reviewCount?: number;
+    priceRange?: string;
+    imageUrl?: string;
+    profileUrl?: string;
+}
+export interface RestaurantDetails extends Restaurant {
+    description?: string;
+    address?: string;
+    phone?: string;
+    hours?: string;
+    website?: string;
+    features?: string[];
+}
+export interface AvailabilitySlot {
+    time: string;
+    partySize: number;
+    date: string;
+    reservationToken?: string;
+}
+export interface Reservation {
+    id: string;
+    restaurantName: string;
+    date: string;
+    time: string;
+    partySize: number;
+    status: string;
+    confirmationNumber?: string;
+    specialRequests?: string;
+}
+/**
+ * Check if user is logged in to OpenTable
+ */
+export declare function checkAuth(): Promise<AuthState>;
+/**
+ * Return login URL and instructions for the user to authenticate
+ */
+export declare function getLoginUrl(): Promise<{
+    url: string;
+    instructions: string;
+}>;
+/**
+ * Search restaurants on OpenTable
+ */
+export declare function searchRestaurants(params: {
+    location: string;
+    cuisine?: string;
+    partySize?: number;
+    date?: string;
+    time?: string;
+}): Promise<{
+    success: boolean;
+    restaurants?: Restaurant[];
+    error?: string;
+}>;
+/**
+ * Get detailed information about a specific restaurant
+ */
+export declare function getRestaurantDetails(restaurantId: string): Promise<{
+    success: boolean;
+    restaurant?: RestaurantDetails;
+    error?: string;
+}>;
+/**
+ * Check available reservation times for a restaurant
+ */
+export declare function checkAvailability(params: {
+    restaurantId: string;
+    date: string;
+    time: string;
+    partySize: number;
+}): Promise<{
+    success: boolean;
+    slots?: AvailabilitySlot[];
+    restaurantName?: string;
+    error?: string;
+}>;
+/**
+ * Make a reservation at a restaurant
+ */
+export declare function makeReservation(params: {
+    restaurantId: string;
+    date: string;
+    time: string;
+    partySize: number;
+    firstName?: string;
+    lastName?: string;
+    email?: string;
+    phone?: string;
+    specialRequests?: string;
+    confirm: boolean;
+}): Promise<{
+    success: boolean;
+    reservation?: Partial<Reservation>;
+    requiresConfirmation?: boolean;
+    preview?: {
+        restaurantName: string;
+        date: string;
+        time: string;
+        partySize: number;
+        specialRequests?: string;
+    };
+    error?: string;
+}>;
+/**
+ * Get list of upcoming reservations
+ */
+export declare function getReservations(): Promise<{
+    success: boolean;
+    reservations?: Reservation[];
+    error?: string;
+}>;
+/**
+ * Cancel a reservation
+ */
+export declare function cancelReservation(params: {
+    reservationId: string;
+    confirm: boolean;
+}): Promise<{
+    success: boolean;
+    requiresConfirmation?: boolean;
+    message?: string;
+    error?: string;
+}>;
+/**
+ * Cleanup browser resources
+ */
+export declare function cleanup(): Promise<void>;