@striderlabs/mcp-zillow 1.0.0

package/README.md

@@ -0,0 +1,188 @@
+# @striderlabs/mcp-zillow
+
+An MCP (Model Context Protocol) server for Zillow real estate search and listings. Search for homes, get property details, retrieve Zestimates, and search rental listings — all from within Claude or any MCP-compatible client.
+
+## Installation
+
+### 1. Install the package
+
+```bash
+npm install @striderlabs/mcp-zillow
+```
+
+### 2. Install Playwright Chromium browser
+
+```bash
+npx playwright install chromium
+```
+
+## MCP Configuration
+
+### Claude Desktop
+
+Add to your `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+  "mcpServers": {
+    "zillow": {
+      "command": "npx",
+      "args": ["mcp-zillow"]
+    }
+  }
+}
+```
+
+Or if installed globally:
+
+```json
+{
+  "mcpServers": {
+    "zillow": {
+      "command": "mcp-zillow"
+    }
+  }
+}
+```
+
+## Tools
+
+### `search_homes`
+
+Search Zillow for homes for sale by location with optional filters.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `location` | string | Yes | City, state, zip code, or neighborhood (e.g. "Seattle, WA" or "90210") |
+| `min_price` | number | No | Minimum listing price in dollars |
+| `max_price` | number | No | Maximum listing price in dollars |
+| `min_beds` | number | No | Minimum number of bedrooms |
+| `max_beds` | number | No | Maximum number of bedrooms |
+| `min_baths` | number | No | Minimum number of bathrooms |
+| `home_type` | string | No | One of: `single_family`, `condo`, `townhouse`, `multi_family`, `land`, `mobile` |
+| `max_results` | number | No | Maximum results to return (default: 10) |
+
+**Example:**
+```
+Search for 3-bedroom homes in Austin, TX under $500,000
+```
+
+---
+
+### `get_listing`
+
+Get detailed information about a specific Zillow listing including price history, school ratings, tax history, and full property details.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `url` | string | No* | Full Zillow listing URL |
+| `zpid` | string | No* | Zillow property ID |
+
+*At least one of `url` or `zpid` is required.
+
+**Example:**
+```
+Get details for Zillow property zpid 12345678
+```
+
+---
+
+### `get_estimates`
+
+Get the Zestimate (Zillow's estimated market value) and rent estimate for a specific address.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `address` | string | Yes | Full property address (e.g. "123 Main St, Seattle, WA 98101") |
+
+**Example:**
+```
+What is the Zestimate for 1600 Pennsylvania Ave NW, Washington, DC 20500?
+```
+
+---
+
+### `save_home`
+
+Save a home to Zillow favorites. Note: This requires Zillow authentication and currently returns instructions for manual saving.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `zpid` | string | Yes | Zillow property ID to save |
+| `note` | string | No | Optional note to attach |
+
+---
+
+### `search_rentals`
+
+Search Zillow for rental properties by location with optional filters.
+
+**Parameters:**
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `location` | string | Yes | City, state, zip code, or neighborhood (e.g. "Austin, TX") |
+| `min_price` | number | No | Minimum monthly rent in dollars |
+| `max_price` | number | No | Maximum monthly rent in dollars |
+| `min_beds` | number | No | Minimum number of bedrooms |
+| `max_beds` | number | No | Maximum number of bedrooms |
+| `max_results` | number | No | Maximum results to return (default: 10) |
+
+**Example:**
+```
+Find 2-bedroom apartments for rent in Brooklyn, NY under $3000/month
+```
+
+## Example Usage
+
+Once configured in Claude Desktop, you can ask questions like:
+
+- "Find homes for sale in Denver, CO with at least 3 bedrooms under $600,000"
+- "What are rental prices like in San Francisco for 1-bedroom apartments?"
+- "Get the Zestimate and details for 123 Main St, Portland, OR 97201"
+- "Show me condos for sale in Miami Beach under $400,000"
+- "Search for townhouses in Chicago with 2+ baths between $300,000 and $500,000"
+
+## How It Works
+
+This MCP server uses Playwright to automate a headless Chromium browser to access Zillow. It:
+
+1. Launches a stealth-configured browser (mimics real user behavior)
+2. Navigates to relevant Zillow pages
+3. Extracts data from Zillow's embedded `__NEXT_DATA__` JSON
+4. Falls back to CSS selector parsing if JSON is unavailable
+5. Returns structured data to the MCP client
+
+## Notes
+
+- **Rate limiting**: Zillow may rate-limit or block automated requests. The server uses stealth techniques to minimize this.
+- **Authentication**: Some features (saving homes) require a Zillow account. The server operates in anonymous mode for search and data retrieval.
+- **Data freshness**: Data is fetched live from Zillow on each request.
+- **Playwright**: The server requires Chromium to be installed via `npx playwright install chromium`.
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/markswendsen-code/mcp-zillow.git
+cd mcp-zillow
+
+# Install dependencies
+npm install
+
+# Install Playwright browser
+npx playwright install chromium
+
+# Build
+npm run build
+
+# Run in development mode
+npm run dev
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@striderlabs/mcp-zillow",
+  "version": "1.0.0",
+  "description": "MCP server for Zillow real estate search and listings",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-zillow": "dist/index.js"
+  },
+  "mcpName": "io.github.markswendsen-code/mcp-zillow",
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --external:playwright",
+    "dev": "ts-node src/index.ts",
+    "pack": "npm run build && npm pack"
+  },
+  "keywords": ["mcp", "zillow", "real-estate", "playwright"],
+  "author": "StriiderLabs",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "playwright": "^1.40.0",
+    "playwright-extra": "^4.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.19.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,651 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { chromium, Browser, Page } from "playwright";
+
+// Server setup
+const server = new Server(
+  {
+    name: "io.github.markswendsen-code/mcp-zillow",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+let browser: Browser | null = null;
+
+async function getBrowser(): Promise<Browser> {
+  if (!browser) {
+    browser = await chromium.launch({
+      headless: true,
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-accelerated-2d-canvas",
+        "--no-first-run",
+        "--no-zygote",
+        "--disable-gpu",
+      ],
+    });
+  }
+  return browser;
+}
+
+async function getStealthPage(browser: Browser): Promise<Page> {
+  const context = await browser.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 },
+    extraHTTPHeaders: {
+      Accept:
+        "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5",
+      "Accept-Encoding": "gzip, deflate, br",
+      Connection: "keep-alive",
+      "Upgrade-Insecure-Requests": "1",
+    },
+  });
+
+  const page = await context.newPage();
+
+  // Remove webdriver flag
+  await page.addInitScript(() => {
+    Object.defineProperty(navigator, "webdriver", {
+      get: () => undefined,
+    });
+  });
+
+  return page;
+}
+
+async function dismissPopups(page: Page): Promise<void> {
+  // Try to dismiss cookie consent
+  const cookieSelectors = [
+    'button[data-test="cookie-consent-accept"]',
+    'button:has-text("Accept")',
+    'button:has-text("Accept All")',
+    "#onetrust-accept-btn-handler",
+  ];
+
+  for (const selector of cookieSelectors) {
+    try {
+      const el = await page.$(selector);
+      if (el) {
+        await el.click();
+        await page.waitForTimeout(500);
+        break;
+      }
+    } catch {}
+  }
+
+  // Try to dismiss sign-in modal
+  const closeSelectors = [
+    'button[aria-label="Close"]',
+    'button[data-test="modal-close"]',
+    ".modal-close",
+  ];
+
+  for (const selector of closeSelectors) {
+    try {
+      const el = await page.$(selector);
+      if (el) {
+        await el.click();
+        await page.waitForTimeout(500);
+        break;
+      }
+    } catch {}
+  }
+}
+
+async function extractNextData(page: Page): Promise<any> {
+  try {
+    const data = await page.evaluate(() => {
+      const script = document.getElementById("__NEXT_DATA__");
+      if (script) {
+        return JSON.parse(script.textContent || "{}");
+      }
+      return null;
+    });
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+// Tool: search_homes
+async function searchHomes(params: {
+  location: string;
+  min_price?: number;
+  max_price?: number;
+  min_beds?: number;
+  max_beds?: number;
+  min_baths?: number;
+  home_type?: string;
+  max_results?: number;
+}): Promise<any> {
+  const browser = await getBrowser();
+  const page = await getStealthPage(browser);
+
+  try {
+    const location = params.location.replace(/\s+/g, "-").replace(/,/g, "");
+    let url = `https://www.zillow.com/homes/for_sale/${encodeURIComponent(location)}_rb/`;
+
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+    await page.waitForTimeout(2000);
+    await dismissPopups(page);
+
+    const nextData = await extractNextData(page);
+    const results: any[] = [];
+
+    if (nextData?.props?.pageProps?.searchPageState?.cat1?.searchResults?.listResults) {
+      const listings =
+        nextData.props.pageProps.searchPageState.cat1.searchResults.listResults;
+
+      for (const listing of listings.slice(0, params.max_results || 10)) {
+        if (!listing.zpid) continue;
+
+        // Apply filters
+        if (params.min_price && listing.price < params.min_price) continue;
+        if (params.max_price && listing.price > params.max_price) continue;
+        if (params.min_beds && listing.beds < params.min_beds) continue;
+        if (params.max_beds && listing.beds > params.max_beds) continue;
+        if (params.min_baths && listing.baths < params.min_baths) continue;
+
+        results.push({
+          zpid: listing.zpid,
+          address: listing.address,
+          price: listing.price,
+          beds: listing.beds,
+          baths: listing.baths,
+          sqft: listing.area,
+          home_type: listing.homeType,
+          listing_url: listing.detailUrl
+            ? `https://www.zillow.com${listing.detailUrl}`
+            : null,
+          days_on_zillow: listing.daysOnZillow,
+          broker: listing.brokerName,
+          latitude: listing.latLong?.latitude,
+          longitude: listing.latLong?.longitude,
+          zestimate: listing.zestimate,
+          img_url: listing.imgSrc,
+        });
+      }
+    }
+
+    if (results.length === 0) {
+      // Try alternate data path
+      const altListings =
+        nextData?.props?.pageProps?.searchPageState?.cat1?.searchResults?.mapResults;
+      if (altListings) {
+        for (const listing of altListings.slice(0, params.max_results || 10)) {
+          if (!listing.zpid) continue;
+          results.push({
+            zpid: listing.zpid,
+            address: listing.address,
+            price: listing.price,
+            beds: listing.beds,
+            baths: listing.baths,
+            sqft: listing.area,
+            home_type: listing.homeType,
+            listing_url: listing.detailUrl
+              ? `https://www.zillow.com${listing.detailUrl}`
+              : null,
+            zestimate: listing.zestimate,
+          });
+        }
+      }
+    }
+
+    return {
+      location: params.location,
+      total_found: results.length,
+      listings: results,
+    };
+  } finally {
+    await page.context().close();
+  }
+}
+
+// Tool: get_listing
+async function getListing(params: {
+  url?: string;
+  zpid?: string;
+}): Promise<any> {
+  const browser = await getBrowser();
+  const page = await getStealthPage(browser);
+
+  try {
+    let url = params.url;
+    if (!url && params.zpid) {
+      url = `https://www.zillow.com/homedetails/${params.zpid}_zpid/`;
+    }
+    if (!url) throw new Error("Either url or zpid is required");
+
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+    await page.waitForTimeout(2000);
+    await dismissPopups(page);
+
+    const nextData = await extractNextData(page);
+
+    let listing: any = {};
+
+    if (nextData?.props?.pageProps) {
+      const props = nextData.props.pageProps;
+      const home = props.componentProps?.gdpClientCache
+        ? Object.values(props.componentProps.gdpClientCache)[0]
+        : props.homeDetails;
+
+      if (home?.property) {
+        const p = home.property;
+        listing = {
+          zpid: p.zpid,
+          address: {
+            street: p.streetAddress,
+            city: p.city,
+            state: p.state,
+            zip: p.zipcode,
+            full: `${p.streetAddress}, ${p.city}, ${p.state} ${p.zipcode}`,
+          },
+          price: p.price,
+          zestimate: p.zestimate,
+          rent_zestimate: p.rentZestimate,
+          beds: p.bedrooms,
+          baths: p.bathrooms,
+          sqft: p.livingArea,
+          lot_size: p.lotAreaValue,
+          lot_size_unit: p.lotAreaUnit,
+          home_type: p.homeType,
+          year_built: p.yearBuilt,
+          heating: p.heating,
+          cooling: p.cooling,
+          parking: p.parkingFeatures,
+          description: p.description,
+          listing_status: p.homeStatus,
+          days_on_zillow: p.daysOnZillow,
+          views: p.pageViewCount,
+          saves: p.favoriteCount,
+          hoa_fee: p.monthlyHoaFee,
+          tax_history: p.taxHistory?.slice(0, 3),
+          price_history: p.priceHistory?.slice(0, 5),
+          school_ratings: p.schools?.slice(0, 3).map((s: any) => ({
+            name: s.name,
+            rating: s.rating,
+            level: s.level,
+            distance: s.distance,
+          })),
+          listing_url: url,
+          images: p.photos?.slice(0, 5).map((ph: any) => ph.url),
+        };
+      }
+    }
+
+    return listing;
+  } finally {
+    await page.context().close();
+  }
+}
+
+// Tool: get_estimates
+async function getEstimates(params: { address: string }): Promise<any> {
+  const browser = await getBrowser();
+  const page = await getStealthPage(browser);
+
+  try {
+    // Use page to make the request
+    await page.goto(
+      `https://www.zillow.com/homes/${encodeURIComponent(params.address)}/`,
+      { waitUntil: "domcontentloaded", timeout: 30000 }
+    );
+    await page.waitForTimeout(2000);
+    await dismissPopups(page);
+
+    const nextData = await extractNextData(page);
+
+    let estimate: any = {
+      address: params.address,
+      zestimate: null,
+      rent_zestimate: null,
+    };
+
+    if (nextData?.props?.pageProps) {
+      const props = nextData.props.pageProps;
+      // Try to find property data
+      if (props.componentProps?.gdpClientCache) {
+        const cacheData = Object.values(props.componentProps.gdpClientCache)[0] as any;
+        if (cacheData?.property) {
+          const p = cacheData.property;
+          estimate = {
+            address: params.address,
+            full_address: `${p.streetAddress}, ${p.city}, ${p.state} ${p.zipcode}`,
+            zestimate: p.zestimate,
+            zestimate_range: p.zestimateLowPercent && p.zestimateHighPercent ? {
+              low: Math.round(p.zestimate * (1 - p.zestimateLowPercent / 100)),
+              high: Math.round(p.zestimate * (1 + p.zestimateHighPercent / 100)),
+            } : null,
+            rent_zestimate: p.rentZestimate,
+            last_sold_price: p.lastSoldPrice,
+            last_sold_date: p.lastSoldDate,
+            price_per_sqft: p.resoFacts?.pricePerSquareFoot,
+            sqft: p.livingArea,
+            beds: p.bedrooms,
+            baths: p.bathrooms,
+            year_built: p.yearBuilt,
+          };
+        }
+      }
+    }
+
+    return estimate;
+  } finally {
+    await page.context().close();
+  }
+}
+
+// Tool: save_home
+async function saveHome(params: {
+  zpid: string;
+  note?: string;
+}): Promise<any> {
+  // This requires authentication - return helpful message
+  return {
+    success: false,
+    message:
+      "Saving homes requires Zillow authentication. Please log in to Zillow at https://www.zillow.com and use the save feature directly. This MCP server operates in anonymous mode for search and data retrieval.",
+    zpid: params.zpid,
+    zillow_url: `https://www.zillow.com/homedetails/${params.zpid}_zpid/`,
+  };
+}
+
+// Tool: search_rentals
+async function searchRentals(params: {
+  location: string;
+  min_price?: number;
+  max_price?: number;
+  min_beds?: number;
+  max_beds?: number;
+  max_results?: number;
+}): Promise<any> {
+  const browser = await getBrowser();
+  const page = await getStealthPage(browser);
+
+  try {
+    const location = params.location.replace(/\s+/g, "-").replace(/,/g, "");
+    const url = `https://www.zillow.com/homes/for_rent/${encodeURIComponent(location)}_rb/`;
+
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+    await page.waitForTimeout(2000);
+    await dismissPopups(page);
+
+    const nextData = await extractNextData(page);
+    const results: any[] = [];
+
+    const searchResults =
+      nextData?.props?.pageProps?.searchPageState?.cat1?.searchResults?.listResults ||
+      nextData?.props?.pageProps?.searchPageState?.cat1?.searchResults?.mapResults ||
+      [];
+
+    for (const listing of searchResults.slice(0, params.max_results || 10)) {
+      if (!listing.zpid) continue;
+
+      if (params.min_price && listing.price < params.min_price) continue;
+      if (params.max_price && listing.price > params.max_price) continue;
+      if (params.min_beds && listing.beds < params.min_beds) continue;
+      if (params.max_beds && listing.beds > params.max_beds) continue;
+
+      results.push({
+        zpid: listing.zpid,
+        address: listing.address,
+        monthly_rent: listing.price,
+        beds: listing.beds,
+        baths: listing.baths,
+        sqft: listing.area,
+        home_type: listing.homeType,
+        listing_url: listing.detailUrl
+          ? `https://www.zillow.com${listing.detailUrl}`
+          : null,
+        days_on_zillow: listing.daysOnZillow,
+        broker: listing.brokerName,
+        img_url: listing.imgSrc,
+      });
+    }
+
+    return {
+      location: params.location,
+      total_found: results.length,
+      rentals: results,
+    };
+  } finally {
+    await page.context().close();
+  }
+}
+
+// Register tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "search_homes",
+        description:
+          "Search Zillow for homes for sale by location with optional filters for price, bedrooms, bathrooms, and home type",
+        inputSchema: {
+          type: "object",
+          properties: {
+            location: {
+              type: "string",
+              description:
+                'Location to search (city, state, zip code, or neighborhood). Example: "Seattle, WA" or "90210"',
+            },
+            min_price: {
+              type: "number",
+              description: "Minimum listing price in dollars",
+            },
+            max_price: {
+              type: "number",
+              description: "Maximum listing price in dollars",
+            },
+            min_beds: {
+              type: "number",
+              description: "Minimum number of bedrooms",
+            },
+            max_beds: {
+              type: "number",
+              description: "Maximum number of bedrooms",
+            },
+            min_baths: {
+              type: "number",
+              description: "Minimum number of bathrooms",
+            },
+            home_type: {
+              type: "string",
+              enum: [
+                "single_family",
+                "condo",
+                "townhouse",
+                "multi_family",
+                "land",
+                "mobile",
+              ],
+              description: "Type of home",
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results to return (default: 10)",
+            },
+          },
+          required: ["location"],
+        },
+      },
+      {
+        name: "get_listing",
+        description:
+          "Get detailed information about a specific Zillow listing including price history, school ratings, and property details",
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "Full Zillow listing URL",
+            },
+            zpid: {
+              type: "string",
+              description: "Zillow property ID (zpid)",
+            },
+          },
+        },
+      },
+      {
+        name: "save_home",
+        description:
+          "Save a home to your Zillow favorites (requires Zillow account - returns instructions if not authenticated)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            zpid: {
+              type: "string",
+              description: "Zillow property ID (zpid) to save",
+            },
+            note: {
+              type: "string",
+              description: "Optional note to attach to the saved home",
+            },
+          },
+          required: ["zpid"],
+        },
+      },
+      {
+        name: "get_estimates",
+        description:
+          "Get Zestimate (Zillow's estimated market value) and rent estimate for a specific address",
+        inputSchema: {
+          type: "object",
+          properties: {
+            address: {
+              type: "string",
+              description:
+                'Full property address. Example: "123 Main St, Seattle, WA 98101"',
+            },
+          },
+          required: ["address"],
+        },
+      },
+      {
+        name: "search_rentals",
+        description:
+          "Search Zillow for rental properties by location with optional filters for price and bedrooms",
+        inputSchema: {
+          type: "object",
+          properties: {
+            location: {
+              type: "string",
+              description:
+                'Location to search (city, state, zip code, or neighborhood). Example: "Austin, TX"',
+            },
+            min_price: {
+              type: "number",
+              description: "Minimum monthly rent in dollars",
+            },
+            max_price: {
+              type: "number",
+              description: "Maximum monthly rent in dollars",
+            },
+            min_beds: {
+              type: "number",
+              description: "Minimum number of bedrooms",
+            },
+            max_beds: {
+              type: "number",
+              description: "Maximum number of bedrooms",
+            },
+            max_results: {
+              type: "number",
+              description: "Maximum number of results to return (default: 10)",
+            },
+          },
+          required: ["location"],
+        },
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    let result: any;
+
+    switch (name) {
+      case "search_homes":
+        result = await searchHomes(args as any);
+        break;
+      case "get_listing":
+        result = await getListing(args as any);
+        break;
+      case "save_home":
+        result = await saveHome(args as any);
+        break;
+      case "get_estimates":
+        result = await getEstimates(args as any);
+        break;
+      case "search_rentals":
+        result = await searchRentals(args as any);
+        break;
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error: any) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: error.message,
+            tool: name,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Cleanup on exit
+process.on("SIGINT", async () => {
+  if (browser) await browser.close();
+  process.exit(0);
+});
+
+process.on("SIGTERM", async () => {
+  if (browser) await browser.close();
+  process.exit(0);
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Zillow MCP server running on stdio");
+}
+
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}