@striderlabs/mcp-thumbtack 1.0.0

package/dist/browser.d.ts

@@ -0,0 +1,12 @@
+import { BrowserContext, Page } from "playwright";
+export declare class BrowserManager {
+    private browser;
+    private context;
+    private page;
+    init(): Promise<void>;
+    getPage(): Promise<Page>;
+    getContext(): BrowserContext | null;
+    close(): Promise<void>;
+    isLoggedIn(): Promise<boolean>;
+}
+export declare function getBrowserManager(): BrowserManager;

package/dist/browser.js

@@ -0,0 +1,88 @@
+import { chromium } from "playwright";
+const USER_AGENT = "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";
+export class BrowserManager {
+    browser = null;
+    context = null;
+    page = null;
+    async init() {
+        if (this.browser) {
+            return;
+        }
+        this.browser = await chromium.launch({
+            headless: true,
+            args: [
+                "--no-sandbox",
+                "--disable-setuid-sandbox",
+                "--disable-blink-features=AutomationControlled",
+                "--disable-infobars",
+                "--window-size=1280,800",
+            ],
+        });
+        this.context = await this.browser.newContext({
+            viewport: { width: 1280, height: 800 },
+            userAgent: USER_AGENT,
+            locale: "en-US",
+            timezoneId: "America/New_York",
+            extraHTTPHeaders: {
+                "Accept-Language": "en-US,en;q=0.9",
+            },
+        });
+        // Mask automation signals
+        await this.context.addInitScript(() => {
+            Object.defineProperty(navigator, "webdriver", { get: () => undefined });
+        });
+        this.page = await this.context.newPage();
+    }
+    async getPage() {
+        if (!this.page || !this.browser) {
+            await this.init();
+        }
+        return this.page;
+    }
+    getContext() {
+        return this.context;
+    }
+    async close() {
+        if (this.page) {
+            await this.page.close().catch(() => { });
+            this.page = null;
+        }
+        if (this.context) {
+            await this.context.close().catch(() => { });
+            this.context = null;
+        }
+        if (this.browser) {
+            await this.browser.close().catch(() => { });
+            this.browser = null;
+        }
+    }
+    async isLoggedIn() {
+        const page = await this.getPage();
+        try {
+            // Navigate to thumbtack.com and check for authenticated nav elements
+            await page.goto("https://www.thumbtack.com", {
+                waitUntil: "domcontentloaded",
+                timeout: 30000,
+            });
+            // Check for user profile indicators in nav
+            const loggedIn = await page.evaluate(() => {
+                // Look for sign-in button absence or profile menu presence
+                const signInBtn = document.querySelector('[data-test="sign-in-button"], a[href*="login"], button[data-testid="login"]');
+                const profileMenu = document.querySelector('[data-test="profile-menu"], [data-testid="user-avatar"], .user-avatar');
+                return !signInBtn || !!profileMenu;
+            });
+            return loggedIn;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// Singleton instance
+let browserManagerInstance = null;
+export function getBrowserManager() {
+    if (!browserManagerInstance) {
+        browserManagerInstance = new BrowserManager();
+    }
+    return browserManagerInstance;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { startServer } from "./server.js";
+import { getBrowserManager } from "./browser.js";
+// Handle graceful shutdown
+process.on("SIGINT", async () => {
+    process.stderr.write("Shutting down Thumbtack MCP server...\n");
+    const manager = getBrowserManager();
+    await manager.close();
+    process.exit(0);
+});
+process.on("SIGTERM", async () => {
+    process.stderr.write("Shutting down Thumbtack MCP server...\n");
+    const manager = getBrowserManager();
+    await manager.close();
+    process.exit(0);
+});
+process.on("uncaughtException", async (error) => {
+    process.stderr.write(`Uncaught exception: ${error.message}\n`);
+    const manager = getBrowserManager();
+    await manager.close().catch(() => { });
+    process.exit(1);
+});
+process.on("unhandledRejection", async (reason) => {
+    process.stderr.write(`Unhandled rejection: ${reason}\n`);
+});
+// Start the MCP server
+startServer().catch((error) => {
+    process.stderr.write(`Failed to start server: ${error.message}\n`);
+    process.exit(1);
+});

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function createServer(): Server;
+export declare function startServer(): Promise<void>;

package/dist/server.js

@@ -0,0 +1,276 @@
+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 { searchServices } from "./tools/search-services.js";
+import { getProvider } from "./tools/get-provider.js";
+import { requestQuote } from "./tools/request-quote.js";
+import { viewQuotes } from "./tools/view-quotes.js";
+import { hireProvider } from "./tools/hire-provider.js";
+import { getProjects } from "./tools/get-projects.js";
+export function createServer() {
+    const server = new Server({
+        name: "mcp-thumbtack",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // List tools handler
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "thumbtack_search_services",
+                    description: "Search for service providers on Thumbtack home services marketplace. Returns a list of matching professionals with ratings, reviews, and contact information.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            service_type: {
+                                type: "string",
+                                description: 'Type of service to search for (e.g., "plumber", "house cleaner", "electrician", "photographer")',
+                            },
+                            location: {
+                                type: "string",
+                                description: "City and state or full address (e.g., 'San Francisco, CA')",
+                            },
+                            zip_code: {
+                                type: "string",
+                                description: "ZIP code for location-based search (e.g., '94102')",
+                            },
+                            date: {
+                                type: "string",
+                                description: "Preferred service date in YYYY-MM-DD format",
+                            },
+                            num_people: {
+                                type: "number",
+                                description: "Number of people (relevant for event services)",
+                            },
+                        },
+                        required: ["service_type"],
+                    },
+                },
+                {
+                    name: "thumbtack_get_provider",
+                    description: "Get detailed information about a specific Thumbtack service provider, including their profile, services offered, reviews, and contact information.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            provider_id: {
+                                type: "string",
+                                description: "The Thumbtack provider ID (numeric ID from their profile URL)",
+                            },
+                            provider_url: {
+                                type: "string",
+                                description: "Full URL to the provider's Thumbtack profile page",
+                            },
+                        },
+                    },
+                },
+                {
+                    name: "thumbtack_request_quote",
+                    description: "Request a quote from a specific Thumbtack service provider. Requires authentication - user must be logged in to Thumbtack.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            provider_id: {
+                                type: "string",
+                                description: "The Thumbtack provider ID",
+                            },
+                            service_type: {
+                                type: "string",
+                                description: "Type of service you need",
+                            },
+                            description: {
+                                type: "string",
+                                description: "Detailed description of the project or service needed",
+                            },
+                            location: {
+                                type: "string",
+                                description: "Service location ZIP code or address",
+                            },
+                            contact_info: {
+                                type: "object",
+                                description: "Contact information for the request",
+                                properties: {
+                                    name: {
+                                        type: "string",
+                                        description: "Your name",
+                                    },
+                                    email: {
+                                        type: "string",
+                                        description: "Your email address",
+                                    },
+                                    phone: {
+                                        type: "string",
+                                        description: "Your phone number",
+                                    },
+                                },
+                            },
+                        },
+                        required: ["provider_id", "service_type", "description", "location", "contact_info"],
+                    },
+                },
+                {
+                    name: "thumbtack_view_quotes",
+                    description: "View quotes received from Thumbtack service providers in your inbox. Requires authentication.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            status: {
+                                type: "string",
+                                enum: ["pending", "active", "completed", "archived", "all"],
+                                description: "Filter quotes by status (default: all)",
+                            },
+                        },
+                    },
+                },
+                {
+                    name: "thumbtack_hire_provider",
+                    description: "Hire a service provider from a received quote. This action creates a project and commits to working with the provider. Requires authentication.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            quote_id: {
+                                type: "string",
+                                description: "The ID of the quote to accept",
+                            },
+                            provider_id: {
+                                type: "string",
+                                description: "The Thumbtack provider ID",
+                            },
+                        },
+                        required: ["quote_id", "provider_id"],
+                    },
+                },
+                {
+                    name: "thumbtack_get_projects",
+                    description: "Get current and past projects from your Thumbtack account, including project status, provider information, and completion details. Requires authentication.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            status: {
+                                type: "string",
+                                enum: ["active", "completed", "all"],
+                                description: "Filter projects by status (default: all)",
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+    });
+    // Call tool handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            switch (name) {
+                case "thumbtack_search_services": {
+                    const params = args;
+                    if (!params.service_type) {
+                        return {
+                            content: [{ type: "text", text: "Error: service_type parameter is required" }],
+                            isError: true,
+                        };
+                    }
+                    const result = await searchServices(params);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                case "thumbtack_get_provider": {
+                    const params = args;
+                    if (!params.provider_id && !params.provider_url) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: Either provider_id or provider_url must be provided",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const result = await getProvider(params);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                case "thumbtack_request_quote": {
+                    const params = args;
+                    if (!params.provider_id || !params.service_type || !params.description || !params.location) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: provider_id, service_type, description, and location are required",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const result = await requestQuote(params);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                case "thumbtack_view_quotes": {
+                    const params = (args || {});
+                    const result = await viewQuotes(params);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                case "thumbtack_hire_provider": {
+                    const params = args;
+                    if (!params.quote_id || !params.provider_id) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: quote_id and provider_id are required",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const result = await hireProvider(params);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                case "thumbtack_get_projects": {
+                    const params = (args || {});
+                    const result = await getProjects(params);
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    };
+                }
+                default:
+                    return {
+                        content: [{ type: "text", text: `Error: Unknown tool: ${name}` }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (error) {
+            const err = error;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${err.message || "An unexpected error occurred"}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+export async function startServer() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write("Thumbtack MCP server started\n");
+}

package/dist/session.d.ts

@@ -0,0 +1,5 @@
+import { Page, BrowserContext } from "playwright";
+export declare function saveSession(page: Page, context: BrowserContext): Promise<void>;
+export declare function loadSession(page: Page, context: BrowserContext): Promise<boolean>;
+export declare function clearSession(): Promise<void>;
+export declare function sessionExists(): Promise<boolean>;

package/dist/session.js

@@ -0,0 +1,99 @@
+import { promises as fs } from "fs";
+import * as os from "os";
+import * as path from "path";
+const SESSION_FILE = path.join(os.homedir(), ".thumbtack-session.json");
+export async function saveSession(page, context) {
+    try {
+        // Collect cookies from the browser context
+        const cookies = await context.cookies();
+        // Collect localStorage from thumbtack domain
+        const localStorage = await page.evaluate(() => {
+            const data = {};
+            for (let i = 0; i < window.localStorage.length; i++) {
+                const key = window.localStorage.key(i);
+                if (key) {
+                    const value = window.localStorage.getItem(key);
+                    if (value !== null) {
+                        data[key] = value;
+                    }
+                }
+            }
+            return data;
+        });
+        const sessionData = {
+            cookies: cookies.map((c) => ({
+                name: c.name,
+                value: c.value,
+                domain: c.domain,
+                path: c.path,
+                expires: c.expires,
+                httpOnly: c.httpOnly,
+                secure: c.secure,
+                sameSite: c.sameSite || "Lax",
+            })),
+            localStorage,
+            savedAt: new Date().toISOString(),
+        };
+        await fs.writeFile(SESSION_FILE, JSON.stringify(sessionData, null, 2), {
+            mode: 0o600,
+        });
+    }
+    catch (error) {
+        const err = error;
+        throw new Error(`Failed to save session: ${err.message}`);
+    }
+}
+export async function loadSession(page, context) {
+    try {
+        const raw = await fs.readFile(SESSION_FILE, "utf-8");
+        const sessionData = JSON.parse(raw);
+        // Check session age - invalidate after 7 days
+        const savedAt = new Date(sessionData.savedAt).getTime();
+        const ageMs = Date.now() - savedAt;
+        const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+        if (ageMs > sevenDaysMs) {
+            await clearSession();
+            return false;
+        }
+        // Restore cookies
+        if (sessionData.cookies && sessionData.cookies.length > 0) {
+            await context.addCookies(sessionData.cookies);
+        }
+        // Navigate to thumbtack first so we can set localStorage
+        await page.goto("https://www.thumbtack.com", {
+            waitUntil: "domcontentloaded",
+            timeout: 30000,
+        });
+        // Restore localStorage
+        if (sessionData.localStorage &&
+            Object.keys(sessionData.localStorage).length > 0) {
+            await page.evaluate((data) => {
+                for (const [key, value] of Object.entries(data)) {
+                    window.localStorage.setItem(key, value);
+                }
+            }, sessionData.localStorage);
+        }
+        return true;
+    }
+    catch (error) {
+        // Session file doesn't exist or is invalid
+        return false;
+    }
+}
+export async function clearSession() {
+    try {
+        await fs.unlink(SESSION_FILE);
+    }
+    catch {
+        // File may not exist, that's fine
+    }
+}
+export async function sessionExists() {
+    try {
+        await fs.access(SESSION_FILE);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/get-projects.d.ts

@@ -0,0 +1,27 @@
+export interface GetProjectsParams {
+    status?: "active" | "completed" | "all";
+}
+export interface Project {
+    id: string;
+    title: string;
+    providerName: string;
+    providerUrl: string | null;
+    providerImageUrl: string | null;
+    serviceType: string;
+    status: string;
+    startDate: string | null;
+    completedDate: string | null;
+    price: string | null;
+    location: string | null;
+    description: string | null;
+    hasReview: boolean;
+    rating: number | null;
+    projectUrl: string | null;
+}
+export interface GetProjectsResult {
+    projects: Project[];
+    totalCount: number;
+    requiresLogin: boolean;
+    message: string;
+}
+export declare function getProjects(params: GetProjectsParams): Promise<GetProjectsResult>;