@humbletoes/google-search 1.0.0

package/dist/mcp-server.js

@@ -0,0 +1,822 @@
+#!/usr/bin/env node
+/**
+ * Google Search MCP Server v2.0
+ *
+ * Provides two tools:
+ * - google-search: Smart web search and content fetcher
+ * - get_code_context: Programming documentation and code examples search
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { googleSearch } from "./search.js";
+import { fetchWebContent } from "./web-fetcher.js";
+import * as os from "os";
+import * as path from "path";
+import logger from "./logger.js";
+import { browserPool } from "./browser-pool.js";
+import { SearchCache } from "./cache.js";
+import { InputValidator } from "./validation.js";
+import { RetryManager } from "./errors.js";
+import { spawn } from "child_process";
+// =============================================================================
+// CONSTANTS & CONFIGURATION
+// =============================================================================
+const SERVER_VERSION = "1.0.0";
+const CONTEXT7_API_BASE = "https://context7.com/api";
+const CONTEXT7_TIMEOUT = 5000;
+const DEFAULT_SEARCH_LIMIT = 20;
+const DEFAULT_FETCH_TIMEOUT = 30000;
+const DEFAULT_SEARCH_TIMEOUT = 60000;
+const DEFAULT_CODE_CONTEXT_RESULTS = 5;
+const DEFAULT_CODE_CONTEXT_TOKENS = 3000;
+const CHARS_PER_TOKEN = 4;
+// Browser state file path
+const STATE_FILE_PATH = path.join(os.homedir(), ".google-search-browser-state.json");
+// Global cache instance (singleton)
+const searchCache = new SearchCache();
+// =============================================================================
+// LIBRARY CONFIGURATION
+// =============================================================================
+/** Known libraries for Context7 lookup and doc site targeting */
+const KNOWN_LIBRARIES = {
+    // Frontend Frameworks
+    'react': { canonical: 'react', docSites: 'site:react.dev OR site:reactjs.org' },
+    'next': { canonical: 'next.js', docSites: 'site:nextjs.org' },
+    'nextjs': { canonical: 'next.js', docSites: 'site:nextjs.org' },
+    'vue': { canonical: 'vue', docSites: 'site:vuejs.org' },
+    'angular': { canonical: 'angular', docSites: 'site:angular.io' },
+    'svelte': { canonical: 'svelte', docSites: 'site:svelte.dev' },
+    'solid': { canonical: 'solid', docSites: 'site:solidjs.com' },
+    // Backend Frameworks
+    'express': { canonical: 'express', docSites: 'site:expressjs.com' },
+    'fastify': { canonical: 'fastify', docSites: 'site:fastify.io' },
+    'koa': { canonical: 'koa' },
+    'hono': { canonical: 'hono', docSites: 'site:hono.dev' },
+    'nest': { canonical: 'nestjs', docSites: 'site:docs.nestjs.com' },
+    'nestjs': { canonical: 'nestjs', docSites: 'site:docs.nestjs.com' },
+    // Python
+    'python': { canonical: 'python', docSites: 'site:docs.python.org' },
+    'django': { canonical: 'django', docSites: 'site:docs.djangoproject.com' },
+    'flask': { canonical: 'flask', docSites: 'site:flask.palletsprojects.com' },
+    'fastapi': { canonical: 'fastapi', docSites: 'site:fastapi.tiangolo.com' },
+    'pandas': { canonical: 'pandas', docSites: 'site:pandas.pydata.org' },
+    'numpy': { canonical: 'numpy', docSites: 'site:numpy.org' },
+    // Rust
+    'rust': { canonical: 'rust', docSites: 'site:doc.rust-lang.org OR site:docs.rs' },
+    'tokio': { canonical: 'tokio', docSites: 'site:tokio.rs' },
+    'actix': { canonical: 'actix', docSites: 'site:actix.rs' },
+    'axum': { canonical: 'axum' },
+    // Go
+    'go': { canonical: 'go', docSites: 'site:go.dev OR site:golang.org' },
+    'golang': { canonical: 'go', docSites: 'site:go.dev OR site:golang.org' },
+    'gin': { canonical: 'gin' },
+    'echo': { canonical: 'echo' },
+    'fiber': { canonical: 'fiber' },
+    // Languages & Typing
+    'typescript': { canonical: 'typescript', docSites: 'site:typescriptlang.org' },
+    'node': { canonical: 'node.js', docSites: 'site:nodejs.org' },
+    'nodejs': { canonical: 'node.js', docSites: 'site:nodejs.org' },
+    'deno': { canonical: 'deno', docSites: 'site:deno.land' },
+    'bun': { canonical: 'bun', docSites: 'site:bun.sh' },
+    // Validation & Schema
+    'zod': { canonical: 'zod' },
+    'trpc': { canonical: 'trpc', docSites: 'site:trpc.io' },
+    'graphql': { canonical: 'graphql', docSites: 'site:graphql.org' },
+    'apollo': { canonical: 'apollo', docSites: 'site:apollographql.com' },
+    // CSS & Styling
+    'tailwind': { canonical: 'tailwindcss', docSites: 'site:tailwindcss.com' },
+    'tailwindcss': { canonical: 'tailwindcss', docSites: 'site:tailwindcss.com' },
+    // Database & ORM
+    'prisma': { canonical: 'prisma', docSites: 'site:prisma.io' },
+    'drizzle': { canonical: 'drizzle', docSites: 'site:orm.drizzle.team' },
+    'typeorm': { canonical: 'typeorm' },
+    'sequelize': { canonical: 'sequelize' },
+    'mongodb': { canonical: 'mongodb', docSites: 'site:mongodb.com/docs' },
+    'mongoose': { canonical: 'mongoose', docSites: 'site:mongoosejs.com' },
+    'postgres': { canonical: 'postgresql', docSites: 'site:postgresql.org/docs' },
+    'postgresql': { canonical: 'postgresql', docSites: 'site:postgresql.org/docs' },
+    'redis': { canonical: 'redis', docSites: 'site:redis.io' },
+    'sqlite': { canonical: 'sqlite', docSites: 'site:sqlite.org' },
+    // Cloud & Infrastructure
+    'docker': { canonical: 'docker', docSites: 'site:docs.docker.com' },
+    'kubernetes': { canonical: 'kubernetes', docSites: 'site:kubernetes.io/docs' },
+    'k8s': { canonical: 'kubernetes', docSites: 'site:kubernetes.io/docs' },
+    'aws': { canonical: 'aws', docSites: 'site:docs.aws.amazon.com' },
+    'azure': { canonical: 'azure', docSites: 'site:docs.microsoft.com/azure' },
+    'gcp': { canonical: 'gcp', docSites: 'site:cloud.google.com/docs' },
+    'firebase': { canonical: 'firebase', docSites: 'site:firebase.google.com/docs' },
+    'supabase': { canonical: 'supabase', docSites: 'site:supabase.com/docs' },
+    'vercel': { canonical: 'vercel', docSites: 'site:vercel.com/docs' },
+    'cloudflare': { canonical: 'cloudflare', docSites: 'site:developers.cloudflare.com' },
+    // APIs & Services
+    'stripe': { canonical: 'stripe', docSites: 'site:stripe.com/docs' },
+    'openai': { canonical: 'openai', docSites: 'site:platform.openai.com/docs' },
+    'anthropic': { canonical: 'anthropic', docSites: 'site:docs.anthropic.com' },
+    'langchain': { canonical: 'langchain', docSites: 'site:langchain.com' },
+    // Testing
+    'playwright': { canonical: 'playwright', docSites: 'site:playwright.dev' },
+    'puppeteer': { canonical: 'puppeteer', docSites: 'site:pptr.dev' },
+    'cypress': { canonical: 'cypress', docSites: 'site:docs.cypress.io' },
+    'vitest': { canonical: 'vitest', docSites: 'site:vitest.dev' },
+    'jest': { canonical: 'jest', docSites: 'site:jestjs.io' },
+    // Build Tools
+    'webpack': { canonical: 'webpack', docSites: 'site:webpack.js.org' },
+    'vite': { canonical: 'vite', docSites: 'site:vitejs.dev' },
+    'esbuild': { canonical: 'esbuild', docSites: 'site:esbuild.github.io' },
+    'rollup': { canonical: 'rollup', docSites: 'site:rollupjs.org' },
+    'turbopack': { canonical: 'turbopack' },
+    // State Management
+    'redux': { canonical: 'redux', docSites: 'site:redux.js.org' },
+    'zustand': { canonical: 'zustand' },
+    'jotai': { canonical: 'jotai' },
+    'recoil': { canonical: 'recoil' },
+    'tanstack': { canonical: 'tanstack', docSites: 'site:tanstack.com' },
+    'react-query': { canonical: 'tanstack-query', docSites: 'site:tanstack.com' },
+    'swr': { canonical: 'swr', docSites: 'site:swr.vercel.app' },
+    // Animation
+    'framer': { canonical: 'framer-motion', docSites: 'site:framer.com/motion' },
+    'motion': { canonical: 'framer-motion', docSites: 'site:framer.com/motion' },
+    'gsap': { canonical: 'gsap', docSites: 'site:gsap.com' },
+    // Graphics & Visualization
+    'three': { canonical: 'three.js', docSites: 'site:threejs.org' },
+    'threejs': { canonical: 'three.js', docSites: 'site:threejs.org' },
+    'd3': { canonical: 'd3', docSites: 'site:d3js.org' },
+    'chart': { canonical: 'chart.js', docSites: 'site:chartjs.org' },
+};
+/** Priority scores for code-relevant domains */
+const DOMAIN_PRIORITIES = {
+    'github.com': 10,
+    'stackoverflow.com': 9,
+    'docs.': 8,
+    'documentation': 7,
+    'developer.': 7,
+    'dev.to': 6,
+    'medium.com': 5,
+    'npmjs.com': 5,
+    'pypi.org': 5,
+    'crates.io': 5,
+    'pkg.go.dev': 5,
+};
+// =============================================================================
+// UTILITY FUNCTIONS
+// =============================================================================
+/**
+ * Detect if input is a URL or a search query
+ */
+function isUrl(input) {
+    const trimmed = input.trim();
+    // Check for explicit protocol
+    try {
+        const url = new URL(trimmed);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        // Check for common URL patterns without protocol
+        return /^(www\.)?[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z]{2,})+([\/\?#].*)?$/.test(trimmed);
+    }
+}
+/**
+ * Normalize URL (add https:// if missing)
+ */
+function normalizeUrl(input) {
+    const trimmed = input.trim();
+    if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+        return trimmed;
+    }
+    return `https://${trimmed}`;
+}
+/**
+ * Extract library name from query for enhanced search
+ */
+function extractLibraryInfo(query) {
+    const lowerQuery = query.toLowerCase();
+    for (const [key, info] of Object.entries(KNOWN_LIBRARIES)) {
+        // Match whole word or with common separators
+        const pattern = new RegExp(`\\b${key}\\b|${key}[\\s.-]|[\\s.-]${key}`, 'i');
+        if (pattern.test(lowerQuery) || lowerQuery.includes(key)) {
+            return info;
+        }
+    }
+    return null;
+}
+/**
+ * Deduplicate results by URL
+ */
+function deduplicateResults(results) {
+    const seen = new Set();
+    return results.filter(r => {
+        const url = r.link?.toLowerCase();
+        if (!url || seen.has(url))
+            return false;
+        seen.add(url);
+        return true;
+    });
+}
+/**
+ * Prioritize results likely to contain code/documentation
+ */
+function prioritizeCodeResults(results) {
+    return [...results].sort((a, b) => {
+        const getScore = (link) => {
+            const lower = link.toLowerCase();
+            return Object.entries(DOMAIN_PRIORITIES).reduce((score, [domain, priority]) => lower.includes(domain) ? score + priority : score, 0);
+        };
+        return getScore(b.link) - getScore(a.link);
+    });
+}
+/**
+ * Fetch with timeout wrapper
+ */
+async function fetchWithTimeout(url, options, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetch(url, { ...options, signal: controller.signal });
+        return response;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+// =============================================================================
+// CONTEXT7 INTEGRATION
+// =============================================================================
+/**
+ * Resolve library name to Context7 library ID
+ */
+async function resolveContext7Library(libraryName, query) {
+    try {
+        const response = await fetchWithTimeout(`${CONTEXT7_API_BASE}/v1/resolve`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ libraryName, query }),
+        }, CONTEXT7_TIMEOUT);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        if (data.libraries?.length > 0) {
+            const lib = data.libraries[0];
+            return {
+                id: lib.id,
+                title: lib.title,
+                description: lib.description,
+                codeSnippets: lib.codeSnippets,
+                reputation: lib.reputation,
+                benchmarkScore: lib.benchmarkScore,
+            };
+        }
+        return null;
+    }
+    catch (error) {
+        logger.debug({ error, libraryName }, "Context7 resolve failed");
+        return null;
+    }
+}
+/**
+ * Query Context7 documentation
+ */
+async function queryContext7Docs(libraryId, query) {
+    try {
+        const response = await fetchWithTimeout(`${CONTEXT7_API_BASE}/v1/query`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ libraryId, query }),
+        }, CONTEXT7_TIMEOUT);
+        if (!response.ok)
+            return [];
+        const data = await response.json();
+        return (data.results || []).map((r) => ({
+            title: r.title || "Documentation",
+            source: r.source || r.url || "",
+            content: r.content || r.text || "",
+            code: r.code || r.snippet || "",
+        }));
+    }
+    catch (error) {
+        logger.debug({ error, libraryId }, "Context7 query failed");
+        return [];
+    }
+}
+// =============================================================================
+// FORMATTING FUNCTIONS
+// =============================================================================
+/**
+ * Format search results in a condensed, token-efficient format
+ */
+function formatSearchResults(results, condensed) {
+    if (!results.results?.length) {
+        return `No results for "${results.query}"`;
+    }
+    const lines = [
+        `# ${results.query}`,
+        `${results.results.length} results • ${results.searchTime || 0}ms${results.fromCache ? ' (cached)' : ''}`,
+        '',
+    ];
+    results.results.forEach((r, idx) => {
+        const num = idx + 1;
+        if (condensed) {
+            lines.push(`${num}. [${r.title}](${r.link})`);
+        }
+        else {
+            lines.push(`**${num}. [${r.title}](${r.link})**`);
+            if (r.snippet) {
+                const cleanSnippet = r.snippet
+                    .replace(/\d{4}年\d{1,2}月\d{1,2}日\s*—\s*/g, '')
+                    .replace(/\s+/g, ' ')
+                    .trim();
+                if (cleanSnippet) {
+                    lines.push(`   ${cleanSnippet}`);
+                }
+            }
+            lines.push('');
+        }
+    });
+    return lines.join('\n');
+}
+/**
+ * Format web fetch results in a condensed format
+ */
+function formatWebContent(result, maxLength) {
+    if (result.error) {
+        return `Error: ${result.url} - ${result.error}`;
+    }
+    const lines = [
+        `# ${result.title || 'Untitled'}`,
+        `${result.url} • ${result.wordCount || 0} words • ${result.fetchTime || 0}ms`,
+        '---',
+        '',
+    ];
+    let content = result.content || '';
+    if (maxLength && content.length > maxLength) {
+        content = content.substring(0, maxLength) + '\n\n[Content truncated...]';
+    }
+    lines.push(content);
+    return lines.join('\n');
+}
+/**
+ * Extract code-relevant content from page text
+ */
+function extractCodeRelevantContent(content, maxLength) {
+    const lines = content.split('\n');
+    const relevantLines = [];
+    let charCount = 0;
+    const codePatterns = [
+        /^(import|export|const|let|var|function|class|def|async|await|return|if|for|while)\b/i,
+        /^(npm|yarn|pnpm|pip|cargo|go\s+get|brew|apt)\s+/i,
+        /[{}()[\]];$/,
+        /=>/,
+        /\$\{.*\}/,
+        /<[A-Z][a-zA-Z0-9]*[\s/>]/,
+        /^\s*@\w+/,
+    ];
+    const skipPatterns = [
+        /^(cookie|privacy|terms|copyright|©|all rights reserved)/i,
+        /^(sign up|log in|subscribe|newsletter|follow us)/i,
+        /^(advertisement|sponsored|ad\s)/i,
+        /^(share|tweet|facebook|linkedin|email this)/i,
+    ];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.length < 3)
+            continue;
+        if (skipPatterns.some(p => p.test(trimmed)))
+            continue;
+        const hasCode = codePatterns.some(p => p.test(trimmed));
+        if (charCount + trimmed.length > maxLength && relevantLines.length > 0)
+            break;
+        // Include line if it has code patterns, is early in the extraction, or is substantial
+        if (hasCode || relevantLines.length < 15 || trimmed.length > 30) {
+            relevantLines.push(trimmed);
+            charCount += trimmed.length + 1;
+        }
+        if (charCount >= maxLength)
+            break;
+    }
+    return relevantLines.join('\n');
+}
+// =============================================================================
+// MCP SERVER SETUP
+// =============================================================================
+const server = new McpServer({
+    name: "google-search-server",
+    version: SERVER_VERSION,
+});
+// =============================================================================
+// TOOL: google-search
+// =============================================================================
+server.tool("google-search", `Smart web search and content fetcher. Auto-detects URLs vs search queries.
+
+SEARCH MODE (query string): Returns structured results with clickable links.
+• Batch queries supported (array) for concurrent search
+• Default ${DEFAULT_SEARCH_LIMIT} results (max 100) with title, URL, snippet
+• condensed=true for minimal output
+
+FETCH MODE (URL input): Extracts clean text from webpage.
+• Removes HTML/scripts/ads/navigation
+• maxContentLength limits output size
+
+Examples: "react hooks" → search | "https://docs.python.org" → fetch`, {
+    query: z
+        .union([z.string(), z.array(z.string())])
+        .describe("Search query, URL to fetch, or array for batch"),
+    limit: z
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe(`Results per query (default: ${DEFAULT_SEARCH_LIMIT}, max: 100)`),
+    timeout: z
+        .number()
+        .min(1000)
+        .max(120000)
+        .optional()
+        .describe(`Timeout ms (default: ${DEFAULT_SEARCH_TIMEOUT} search, ${DEFAULT_FETCH_TIMEOUT} fetch)`),
+    useCache: z
+        .boolean()
+        .optional()
+        .describe("Use cache (default: true)"),
+    condensed: z
+        .boolean()
+        .optional()
+        .describe("Minimal output: title+URL only (default: false)"),
+    maxContentLength: z
+        .number()
+        .min(100)
+        .optional()
+        .describe("Max chars for URL fetch content"),
+}, async (params) => {
+    const { query, limit = DEFAULT_SEARCH_LIMIT, timeout, useCache = true, condensed = false, maxContentLength } = params;
+    const queries = Array.isArray(query) ? query : [query];
+    // Validate queries
+    if (queries.length === 0) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: "No query provided." }],
+        };
+    }
+    if (queries.length > 10) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: "Maximum 10 queries per request." }],
+        };
+    }
+    const allUrls = queries.every(isUrl);
+    const allQueries = queries.every(q => !isUrl(q));
+    if (!allUrls && !allQueries) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: "Cannot mix URLs and search queries in one request." }],
+        };
+    }
+    const mode = allUrls ? 'fetch' : 'search';
+    logger.info({ mode, count: queries.length, limit, condensed }, "google-search");
+    try {
+        if (allUrls) {
+            // URL FETCH MODE
+            const results = await Promise.all(queries.map(async (urlInput) => {
+                let browser;
+                try {
+                    browser = await browserPool.acquire();
+                    const url = normalizeUrl(urlInput);
+                    const retryManager = new RetryManager();
+                    return await retryManager.executeWithRetry(() => fetchWebContent(url, browser, timeout || DEFAULT_FETCH_TIMEOUT));
+                }
+                catch (error) {
+                    return {
+                        url: urlInput,
+                        content: '',
+                        wordCount: 0,
+                        fetchTime: 0,
+                        timestamp: new Date().toISOString(),
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+                finally {
+                    if (browser)
+                        await browserPool.release(browser);
+                }
+            }));
+            const responseText = queries.length === 1
+                ? formatWebContent(results[0], maxContentLength)
+                : results.map((r, i) => `## Page ${i + 1}\n${formatWebContent(r, maxContentLength)}`).join('\n\n');
+            return { content: [{ type: "text", text: responseText }] };
+        }
+        else {
+            // SEARCH MODE
+            const results = await Promise.all(queries.map(async (q) => {
+                let browser;
+                try {
+                    const sanitizedQuery = InputValidator.validateQuery(q);
+                    if (useCache) {
+                        const cached = searchCache.get(sanitizedQuery, limit);
+                        if (cached) {
+                            return { ...cached, query: sanitizedQuery, fromCache: true };
+                        }
+                    }
+                    browser = await browserPool.acquire();
+                    const retryManager = new RetryManager();
+                    const searchResults = await retryManager.executeWithRetry(() => googleSearch(sanitizedQuery, { limit, timeout, stateFile: STATE_FILE_PATH }, browser));
+                    if (useCache) {
+                        searchCache.set(sanitizedQuery, searchResults, limit);
+                    }
+                    return { ...searchResults, query: sanitizedQuery, fromCache: false };
+                }
+                catch (error) {
+                    return {
+                        query: q,
+                        results: [],
+                        searchTime: 0,
+                        fromCache: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    };
+                }
+                finally {
+                    if (browser)
+                        await browserPool.release(browser);
+                }
+            }));
+            const responseText = queries.length === 1
+                ? formatSearchResults(results[0], condensed)
+                : results.map((r, i) => `---\n## Query ${i + 1}/${results.length}\n${formatSearchResults(r, condensed)}`).join('\n\n');
+            return { content: [{ type: "text", text: responseText }] };
+        }
+    }
+    catch (error) {
+        logger.error({ error }, "google-search error");
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed: ${error instanceof Error ? error.message : String(error)}` }],
+        };
+    }
+});
+// =============================================================================
+// TOOL: get_code_context
+// =============================================================================
+server.tool("get_code_context", `Search for programming documentation, code examples, and API references.
+
+Uses Context7 + Google Search for high-quality library docs.
+Optimized for: libraries, frameworks, SDKs, APIs, code patterns.
+Returns condensed code snippets from authoritative sources.
+
+Examples:
+• "React useState hook examples"
+• "Python pandas dataframe filtering"  
+• "Next.js app router server actions"
+• "Express middleware authentication"`, {
+    query: z
+        .string()
+        .min(2)
+        .max(500)
+        .describe("Programming topic, library, API, or code pattern"),
+    maxResults: z
+        .number()
+        .min(1)
+        .max(10)
+        .optional()
+        .describe(`Sources to search (default: ${DEFAULT_CODE_CONTEXT_RESULTS}, max: 10)`),
+    maxTokens: z
+        .number()
+        .min(500)
+        .max(10000)
+        .optional()
+        .describe(`Approx max output tokens (default: ${DEFAULT_CODE_CONTEXT_TOKENS})`),
+}, async (params) => {
+    const { query, maxResults = DEFAULT_CODE_CONTEXT_RESULTS, maxTokens = DEFAULT_CODE_CONTEXT_TOKENS } = params;
+    logger.info({ query, maxResults, maxTokens }, "get_code_context");
+    try {
+        const maxChars = maxTokens * CHARS_PER_TOKEN;
+        let currentChars = 0;
+        const outputLines = [];
+        outputLines.push(`## Code Context: ${query}`);
+        outputLines.push('');
+        currentChars += query.length + 25;
+        // Try Context7 first for known libraries
+        const libraryInfo = extractLibraryInfo(query);
+        let context7Results = [];
+        if (libraryInfo) {
+            logger.info({ library: libraryInfo.canonical }, "Attempting Context7 lookup");
+            const library = await resolveContext7Library(libraryInfo.canonical, query);
+            if (library) {
+                logger.info({ libraryId: library.id, title: library.title }, "Found Context7 library");
+                context7Results = await queryContext7Docs(library.id, query);
+                if (context7Results.length > 0) {
+                    outputLines.push(`### 📚 ${library.title} Documentation`);
+                    outputLines.push('');
+                    for (const doc of context7Results.slice(0, 3)) {
+                        if (currentChars >= maxChars * 0.7)
+                            break;
+                        const section = [`#### ${doc.title}`];
+                        if (doc.source)
+                            section.push(`Source: ${doc.source}`);
+                        section.push('');
+                        if (doc.code) {
+                            section.push('```');
+                            section.push(doc.code.substring(0, 1500));
+                            section.push('```');
+                        }
+                        else if (doc.content) {
+                            section.push(doc.content.substring(0, 800));
+                        }
+                        section.push('');
+                        const sectionText = section.join('\n');
+                        if (currentChars + sectionText.length < maxChars * 0.7) {
+                            outputLines.push(sectionText);
+                            currentChars += sectionText.length;
+                        }
+                    }
+                }
+            }
+        }
+        // Supplement with Google search
+        if (currentChars < maxChars * 0.5) {
+            const searchQuery = libraryInfo?.docSites
+                ? `${query} ${libraryInfo.docSites}`
+                : `${query} site:github.com OR site:stackoverflow.com OR site:dev.to`;
+            let browser;
+            let searchResults = [];
+            try {
+                browser = await browserPool.acquire();
+                const retryManager = new RetryManager();
+                const search = await retryManager.executeWithRetry(() => googleSearch(searchQuery, {
+                    limit: Math.min(maxResults * 2, 15),
+                    stateFile: STATE_FILE_PATH
+                }, browser));
+                searchResults = search.results || [];
+            }
+            catch (error) {
+                logger.debug({ error }, "Google search fallback failed");
+            }
+            finally {
+                if (browser)
+                    await browserPool.release(browser);
+            }
+            const uniqueResults = deduplicateResults(searchResults);
+            const prioritizedResults = prioritizeCodeResults(uniqueResults).slice(0, maxResults);
+            if (prioritizedResults.length > 0) {
+                // Fetch content from top results
+                const fetchCount = context7Results.length > 0 ? 2 : 3;
+                const enrichedResults = await Promise.all(prioritizedResults.slice(0, fetchCount).map(async (result) => {
+                    let browser;
+                    try {
+                        browser = await browserPool.acquire();
+                        const content = await fetchWebContent(result.link, browser, 12000);
+                        return { ...result, fetchedContent: content };
+                    }
+                    catch {
+                        return { ...result, fetchedContent: null };
+                    }
+                    finally {
+                        if (browser)
+                            await browserPool.release(browser);
+                    }
+                }));
+                if (context7Results.length > 0) {
+                    outputLines.push('### 🌐 Additional Web Resources');
+                    outputLines.push('');
+                }
+                for (const result of enrichedResults) {
+                    if (currentChars >= maxChars)
+                        break;
+                    if (result.fetchedContent?.content) {
+                        const header = `#### ${result.title}\n${result.link}\n`;
+                        currentChars += header.length;
+                        const content = extractCodeRelevantContent(result.fetchedContent.content, Math.min(1500, maxChars - currentChars));
+                        if (content) {
+                            outputLines.push(header);
+                            outputLines.push('```');
+                            outputLines.push(content);
+                            outputLines.push('```');
+                            outputLines.push('');
+                            currentChars += content.length + 10;
+                        }
+                    }
+                }
+                // Add links to remaining results
+                const remainingResults = prioritizedResults
+                    .filter(r => !enrichedResults.some(e => e.link === r.link))
+                    .slice(0, 5);
+                if (remainingResults.length > 0 && currentChars < maxChars - 300) {
+                    outputLines.push('### 🔗 More Resources');
+                    for (const r of remainingResults) {
+                        outputLines.push(`- [${r.title}](${r.link})`);
+                    }
+                }
+            }
+        }
+        if (outputLines.length <= 2) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No code documentation found for: "${query}"\n\nTry more specific library/framework names.`,
+                    }],
+            };
+        }
+        return { content: [{ type: "text", text: outputLines.join('\n') }] };
+    }
+    catch (error) {
+        logger.error({ error }, "get_code_context error");
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Code context failed: ${error instanceof Error ? error.message : String(error)}` }],
+        };
+    }
+});
+// =============================================================================
+// SERVER LIFECYCLE
+// =============================================================================
+/**
+ * Check if Playwright is available and install it if needed
+ */
+async function ensurePlaywrightInstalled() {
+    try {
+        // Try to import Playwright to check if it's available
+        const { chromium } = await import("playwright");
+        // Try to launch a browser briefly to ensure the browser is installed
+        const browser = await chromium.launch({
+            headless: true,
+            args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"],
+        });
+        await browser.close();
+        logger.info("Playwright is available and ready");
+        return;
+    }
+    catch (error) {
+        logger.warn({ error }, "Playwright not available, installing...");
+        try {
+            // Install Playwright using npx with proper argument escaping
+            await new Promise((resolve, reject) => {
+                const installProcess = spawn("npx", ["playwright", "install", "chromium"], {
+                    stdio: "inherit",
+                });
+                installProcess.on("close", (code) => {
+                    if (code === 0) {
+                        logger.info("Playwright installed successfully");
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(`Playwright installation failed with code ${code}`));
+                    }
+                });
+                installProcess.on("error", (error) => {
+                    reject(new Error(`Failed to start Playwright installation: ${error.message}`));
+                });
+            });
+            // Verify installation worked
+            const { chromium } = await import("playwright");
+            const browser = await chromium.launch({
+                headless: true,
+                args: ["--no-sandbox", "--disable-setuid-sandbox", "--disable-dev-shm-usage"],
+            });
+            await browser.close();
+            logger.info("Playwright installation verified");
+        }
+        catch (installError) {
+            logger.error({ error: installError }, "Failed to install Playwright");
+            throw new Error(`Playwright installation failed: ${installError instanceof Error ? installError.message : String(installError)}`);
+        }
+    }
+}
+async function cleanup() {
+    logger.info("Cleaning up resources...");
+    try {
+        await browserPool.cleanup();
+    }
+    catch (error) {
+        logger.error({ error }, "Cleanup error");
+    }
+}
+async function main() {
+    try {
+        logger.info({ version: SERVER_VERSION }, "Starting Google Search MCP server");
+        // Ensure Playwright is installed and available
+        await ensurePlaywrightInstalled();
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        logger.info("Google Search MCP server ready");
+        // Graceful shutdown handlers
+        const shutdown = async (signal) => {
+            logger.info({ signal }, "Received shutdown signal");
+            await cleanup();
+            process.exit(0);
+        };
+        process.on("SIGINT", () => shutdown("SIGINT"));
+        process.on("SIGTERM", () => shutdown("SIGTERM"));
+        process.on("exit", () => {
+            logger.info("Process exiting");
+        });
+        // Windows-specific handling
+        if (process.platform === "win32") {
+            const readline = await import("readline");
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            rl.on("SIGINT", () => shutdown("SIGINT"));
+        }
+    }
+    catch (error) {
+        logger.error({ error }, "Server start failed");
+        await cleanup();
+        process.exit(1);
+    }
+}
+main();
+//# sourceMappingURL=mcp-server.js.map