crawlforge-mcp-server 3.4.0 → 4.2.1

package/src/skills/crawlforge-mcp.md

@@ -0,0 +1,80 @@
+# CrawlForge MCP Tools — When and How to Use
+
+CrawlForge is a professional MCP server with 23 tools for web scraping, crawling, content extraction, research, and AI compliance.
+
+## When to Use MCP Tools vs CLI
+
+Use MCP tools when you need results inline within an AI assistant session.
+Use the CLI (`crawlforge <command>`) for scripts, CI, and automation pipelines.
+
+## All 23 Tools
+
+### Basic Fetching (5 tools)
+- **fetch_url** — Raw HTTP fetch; returns headers + body. Use for quick single-URL fetches.
+- **extract_text** — Clean readable text from a page (strips HTML). Use for reading articles.
+- **extract_links** — All links from a page with anchor text. Use for link analysis.
+- **extract_metadata** — Title, description, OG tags, schema.org from a page.
+- **scrape_structured** — CSS-selector based data extraction from a page.
+
+### Search (1 tool)
+- **search_web** — Search via CrawlForge API or SearXNG. Supports query expansion, ranking, dedup.
+
+### Crawling (2 tools)
+- **crawl_deep** — BFS crawl up to 1000 pages with configurable depth, content extraction, link analysis.
+- **map_site** — Fast sitemap generation via sitemap.xml or crawl. Returns URL list with metadata.
+
+### Content Extraction (7 tools)
+- **extract_content** — Main content extraction with Readability, markdown output, image handling.
+- **process_document** — PDF, DOCX, TXT processing with chunking and metadata.
+- **summarize_content** — Abstractive summarization (via Ollama/API/sampling).
+- **analyze_content** — Sentiment, entities, readability, keyword density, topic detection.
+- **extract_structured** — JSON schema-driven extraction with LLM or CSS selectors.
+- **extract_with_llm** — Natural language prompt-based extraction. Fallback: Ollama → API keys → sampling.
+- **list_ollama_models** — List locally available Ollama models.
+
+### Advanced (2 tools)
+- **batch_scrape** — Scrape multiple URLs concurrently. Default output: markdown (RAG-ready).
+- **scrape_with_actions** — Browser automation (click, type, scroll, wait) before scraping.
+
+### Research (1 tool)
+- **deep_research** — Multi-stage research: query expansion → parallel fetch → dedup → synthesis.
+
+### Tracking (1 tool)
+- **track_changes** — Snapshot URL and diff against baseline. Returns change percentage + diff.
+
+### LLMs.txt (1 tool)
+- **generate_llms_txt** — Generate llms.txt and llms-full.txt for AI compliance.
+
+### Stealth (1 tool)
+- **stealth_mode** — Anti-bot browser scraping. Engines: playwright (default) or camoufox.
+
+### Localization (1 tool)
+- **localization** — Fetch with locale/geo targeting, proxy routing, currency awareness.
+
+### Templates (1 tool)
+- **scrape_template** — Pre-built extractors for: amazon-product, linkedin-profile, github-repo, youtube-video, tweet, reddit-thread, hacker-news-front-page, producthunt-launch, stackoverflow-question, npm-package.
+
+## Cost Reference (Credits)
+- fetch_url, extract_text, extract_links, extract_metadata: 1 credit
+- search_web, map_site: 2 credits
+- extract_content, scrape_structured, analyze_content, summarize_content: 3 credits
+- crawl_deep, batch_scrape, track_changes, generate_llms_txt: 5 credits
+- extract_structured, extract_with_llm, stealth_mode, localization, scrape_with_actions: 5 credits
+- deep_research: 10–50 credits (dynamic, triggers elicitation when >50)
+
+## Example Tool Calls
+
+Fetch a page:
+```json
+{ "tool": "fetch_url", "params": { "url": "https://example.com" } }
+```
+
+Search the web:
+```json
+{ "tool": "search_web", "params": { "query": "MCP server Node.js", "limit": 5 } }
+```
+
+Extract markdown from an article:
+```json
+{ "tool": "extract_content", "params": { "url": "https://example.com/article", "output_format": "markdown" } }
+```

package/src/skills/crawlforge-research.md

@@ -0,0 +1,104 @@
+# CrawlForge Deep Research Workflow
+
+## When to Use deep_research
+
+Use `deep_research` for comprehensive topic research that requires multiple sources:
+- Competitive analysis (compare multiple competitors)
+- Technology landscape research
+- Fact-gathering with citations
+- Market research with multiple data points
+- Any topic requiring 5+ web sources synthesized
+
+Do NOT use for:
+- Single URL content extraction → use `extract_content`
+- Simple web searches → use `search_web`
+- Known URLs you want to read → use `fetch_url` or `batch_scrape`
+
+## How deep_research Works
+
+1. **Query Expansion** — Generates 3–5 related queries from your topic
+2. **Parallel Fetching** — Fetches up to `max_urls` sources simultaneously
+3. **URL Deduplication** — Skips already-visited URLs within the session
+4. **Content Extraction** — Extracts clean text from each source
+5. **Synthesis** — If Ollama/API key available: returns synthesized report; otherwise returns raw evidence for the calling LLM to synthesize
+
+## LLM Fallback Chain
+
+```
+Ollama (local, default) → OpenAI API key → Anthropic API key → MCP Sampling → Raw evidence
+```
+
+With no LLM configured, `deep_research` returns structured raw evidence that Claude or another LLM can synthesize.
+
+## MCP Tool Usage
+
+```json
+// Standard research
+{
+  "tool": "deep_research",
+  "params": {
+    "query": "React vs Vue vs Angular in 2025",
+    "depth": "standard",
+    "max_urls": 20
+  }
+}
+
+// Deep research with all sources
+{
+  "tool": "deep_research",
+  "params": {
+    "query": "competitor pricing analysis for B2B SaaS",
+    "depth": "deep",
+    "max_urls": 50,
+    "output_format": "detailed"
+  }
+}
+```
+
+Note: When `max_urls > 50`, the tool triggers an elicitation asking for confirmation before proceeding (cost guard).
+
+## CLI Usage
+
+```bash
+# Standard research
+crawlforge research "React vs Vue in 2025" --depth standard
+
+# Deep research with JSON output
+crawlforge research "B2B SaaS pricing trends" --depth deep --max-urls 30 --json
+
+# Save research report to file
+crawlforge research "competitor analysis" --pretty > research-report.json
+```
+
+## Depth Levels
+
+| Depth | URLs Analyzed | Use Case | Approx. Credits |
+|-------|--------------|----------|-----------------|
+| basic | 5–10 | Quick overview | 10–15 |
+| standard | 15–25 | General research | 15–30 |
+| deep | 30–75 | Comprehensive analysis | 30–75+ |
+
+## Cost Management
+
+- `deep_research` costs 10 base credits + 1 per URL analyzed
+- Elicitation fires when projected cost > 50 credits
+- Use `max_urls` to cap costs: `max_urls: 10` ≈ 20 credits max
+- Token budget auto-limits LLM synthesis costs (default: 200,000 chars)
+
+## Accessing Research Results as Resources
+
+Completed research sessions are available as MCP Resources:
+```
+crawlforge://research/{sessionId}
+```
+
+List via `resources/list` — no need to re-run the research.
+
+## Combining with Other Tools
+
+For targeted competitive research:
+```
+1. search_web "competitor X pricing"         → get URLs
+2. batch_scrape [competitor URLs]             → get content in parallel
+3. deep_research "competitor X vs us"         → synthesized analysis
+```

package/src/skills/crawlforge-stealth.md

@@ -0,0 +1,98 @@
+# CrawlForge Stealth Mode Guide
+
+## When to Use stealth_mode
+
+Use `stealth_mode` when a site returns bot-detection errors, 403 responses, CAPTCHAs, or JavaScript-rendered content that `fetch_url` and `extract_content` cannot access.
+
+Signs you need stealth mode:
+- Site returns 403 or 429 on regular fetch
+- Content is empty or shows "please enable JavaScript"
+- Site uses Cloudflare, DataDome, PerimeterX, or similar bot protection
+
+## Engines
+
+### playwright (default)
+- Chromium-based with stealth patches
+- Masks webdriver fingerprints, User-Agent, navigator properties
+- Good for most sites with basic bot detection
+- Lower resource usage
+
+### camoufox
+- Firefox-based with native anti-detection
+- No patches applied — uses Firefox's native properties
+- Scores higher on CreepJS and DataDome than patched Chromium
+- Use for sites with advanced fingerprinting (financial, e-commerce)
+
+## MCP Tool Usage
+
+```json
+// Basic stealth scrape
+{
+  "tool": "stealth_mode",
+  "params": {
+    "url": "https://protected-site.com",
+    "engine": "playwright"
+  }
+}
+
+// Advanced: Camoufox engine with screenshot
+{
+  "tool": "stealth_mode",
+  "params": {
+    "url": "https://heavily-protected-site.com",
+    "engine": "camoufox",
+    "wait_for": 3000,
+    "screenshot": true
+  }
+}
+```
+
+## CLI Usage
+
+```bash
+# Default engine (playwright)
+crawlforge stealth https://protected-site.com
+
+# Camoufox for advanced bot detection bypass
+crawlforge stealth https://protected-site.com --engine camoufox
+
+# Wait for JS-heavy page to render, capture screenshot
+crawlforge stealth https://spa-site.com --wait 3000 --screenshot
+
+# Output as JSON
+crawlforge stealth https://example.com --json
+```
+
+## Engine Selection Guide
+
+| Scenario | Recommended Engine |
+|----------|-------------------|
+| General JS-rendered sites | playwright |
+| Cloudflare-protected sites | camoufox |
+| Sites with DataDome | camoufox |
+| Sites with PerimeterX | camoufox |
+| Financial/trading sites | camoufox |
+| Speed-critical scraping | playwright |
+| Basic bot detection bypass | playwright |
+
+## Environment Variable
+
+Force engine globally:
+```bash
+export CRAWLFORGE_STEALTH_ENGINE=camoufox
+```
+
+## Combining with Other Tools
+
+After extracting raw HTML via stealth_mode, pipe to analyze_content or extract_structured:
+```json
+// Step 1: get HTML via stealth
+{ "tool": "stealth_mode", "params": { "url": "https://example.com" } }
+
+// Step 2: extract structured data from the result
+{ "tool": "extract_structured", "params": { "url": "https://example.com", "schema": {...} } }
+```
+
+## Credits
+- `stealth_mode`: 5 credits per call
+- Additional costs for screenshots (1 extra credit per screenshot)

package/src/skills/installer.js

@@ -0,0 +1,141 @@
+/**
+ * installer.js — Skills installer for CrawlForge.
+ * Installs skill markdown files into Claude Code, Cursor, or VS Code.
+ *
+ * Targets:
+ *   claude-code  — ~/.claude/skills/crawlforge-*.md (one file per skill)
+ *   cursor       — .cursor/rules/crawlforge.mdc (concatenated)
+ *   vscode       — .github/instructions/crawlforge.instructions.md (concatenated)
+ *
+ * Idempotent: skips if already installed (use --force to overwrite).
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Skill files shipped with the package
+const SKILL_FILES = [
+  'crawlforge-mcp.md',
+  'crawlforge-cli.md',
+  'crawlforge-stealth.md',
+  'crawlforge-research.md'
+];
+
+const SKILL_DIR = __dirname; // src/skills/
+
+function readSkillFile(name) {
+  const p = join(SKILL_DIR, name);
+  if (!existsSync(p)) throw new Error(`Skill file not found: ${p}`);
+  return readFileSync(p, 'utf8');
+}
+
+function concatenateSkills() {
+  return SKILL_FILES.map(f => readSkillFile(f)).join('\n\n---\n\n');
+}
+
+/**
+ * Install skills into the given target.
+ * @param {{ target: 'claude-code'|'cursor'|'vscode'|'all', force?: boolean, dryRun?: boolean, cwd?: string }} opts
+ * @returns {{ installed: string[], skipped: string[], paths: string[] }}
+ */
+export async function install({ target = 'all', force = false, dryRun = false, cwd = process.cwd() } = {}) {
+  const targets = target === 'all' ? ['claude-code', 'cursor', 'vscode'] : [target];
+  const results = { installed: [], skipped: [], paths: [] };
+
+  for (const t of targets) {
+    if (t === 'claude-code') {
+      const skillsDir = join(homedir(), '.claude', 'skills');
+      for (const fname of SKILL_FILES) {
+        const dest = join(skillsDir, fname);
+        results.paths.push(dest);
+        if (!dryRun) {
+          if (existsSync(dest) && !force) {
+            results.skipped.push(dest);
+            continue;
+          }
+          mkdirSync(skillsDir, { recursive: true });
+          writeFileSync(dest, readSkillFile(fname), 'utf8');
+        }
+        results.installed.push(dest);
+      }
+    } else if (t === 'cursor') {
+      const dir = join(cwd, '.cursor', 'rules');
+      const dest = join(dir, 'crawlforge.mdc');
+      results.paths.push(dest);
+      if (!dryRun) {
+        if (existsSync(dest) && !force) {
+          results.skipped.push(dest);
+          continue;
+        }
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(dest, concatenateSkills(), 'utf8');
+      }
+      results.installed.push(dest);
+    } else if (t === 'vscode') {
+      const dir = join(cwd, '.github', 'instructions');
+      const dest = join(dir, 'crawlforge.instructions.md');
+      results.paths.push(dest);
+      if (!dryRun) {
+        if (existsSync(dest) && !force) {
+          results.skipped.push(dest);
+          continue;
+        }
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(dest, concatenateSkills(), 'utf8');
+      }
+      results.installed.push(dest);
+    } else {
+      throw new Error(`Unknown target: ${t}. Valid targets: claude-code, cursor, vscode, all`);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Uninstall skills from the given target.
+ * @param {{ target: 'claude-code'|'cursor'|'vscode'|'all', cwd?: string }} opts
+ * @returns {{ removed: string[], notFound: string[] }}
+ */
+export async function uninstall({ target = 'all', cwd = process.cwd() } = {}) {
+  const targets = target === 'all' ? ['claude-code', 'cursor', 'vscode'] : [target];
+  const results = { removed: [], notFound: [] };
+
+  for (const t of targets) {
+    if (t === 'claude-code') {
+      const skillsDir = join(homedir(), '.claude', 'skills');
+      for (const fname of SKILL_FILES) {
+        const dest = join(skillsDir, fname);
+        if (existsSync(dest)) {
+          unlinkSync(dest);
+          results.removed.push(dest);
+        } else {
+          results.notFound.push(dest);
+        }
+      }
+    } else if (t === 'cursor') {
+      const dest = join(cwd, '.cursor', 'rules', 'crawlforge.mdc');
+      if (existsSync(dest)) {
+        unlinkSync(dest);
+        results.removed.push(dest);
+      } else {
+        results.notFound.push(dest);
+      }
+    } else if (t === 'vscode') {
+      const dest = join(cwd, '.github', 'instructions', 'crawlforge.instructions.md');
+      if (existsSync(dest)) {
+        unlinkSync(dest);
+        results.removed.push(dest);
+      } else {
+        results.notFound.push(dest);
+      }
+    }
+  }
+
+  return results;
+}

package/src/tools/advanced/batchScrape/index.js

@@ -15,6 +15,7 @@
  */
 
 import { EventEmitter } from 'events';
+import { ElicitationHelper } from '../../../core/ElicitationHelper.js'; // D1.4
 import JobManager from '../../../core/JobManager.js';
 import WebhookDispatcher from '../../../core/WebhookDispatcher.js';
 import { BatchScrapeSchema } from './schema.js';
@@ -53,6 +54,8 @@ export class BatchScrapeTool extends EventEmitter {
 
     this.activeBatches = new Map();
     this.batchResults = new Map();
+    // D1.4: Elicitation helper (set mcpServer after instantiation if desired)
+    this._elicitation = new ElicitationHelper({});
 
     this.stats = {
       totalBatches: 0,
@@ -68,6 +71,14 @@ export class BatchScrapeTool extends EventEmitter {
     this._initializeJobExecutors();
   }
 
+  /**
+   * D1.4: Set the MCP server instance for elicitation support.
+   * @param {object} mcpServer
+   */
+  setMcpServer(mcpServer) {
+    this._elicitation = new ElicitationHelper({ mcpServer });
+  }
+
   async execute(params) {
     try {
       const validated = BatchScrapeSchema.parse(params);
@@ -84,6 +95,25 @@ export class BatchScrapeTool extends EventEmitter {
         webhookConfig = this._registerWebhook(validated.webhook, batchId);
       }
 
+      // D1.4: Elicitation — warn when batch is large in sync mode
+      if (validated.mode === 'sync' && urlConfigs.length > 25) {
+        const proceed = await this._elicitation.confirm(
+          `batch_scrape (sync mode) will fetch ${urlConfigs.length} URLs synchronously. This may take a while and consume significant credits.`,
+          {
+            url_count: urlConfigs.length,
+            mode: 'sync',
+            suggestion: 'Consider using mode:"async" for large batches.',
+          }
+        );
+        if (!proceed) {
+          return {
+            batchId, mode: 'sync', success: false,
+            error: 'Batch scrape cancelled by user (elicitation declined).',
+            totalUrls: urlConfigs.length,
+          };
+        }
+      }
+
       if (validated.mode === 'sync') {
         return await this._processBatchSync(batchId, urlConfigs, validated, webhookConfig, startTime);
       } else {

package/src/tools/advanced/batchScrape/schema.js

@@ -14,7 +14,7 @@ export const UrlConfigSchema = z.object({
 
 export const BatchScrapeSchema = z.object({
   urls: z.array(z.union([z.string().url(), UrlConfigSchema])).min(1).max(50),
-  formats: z.array(z.enum(['markdown', 'html', 'json', 'text'])).default(['json']),
+  formats: z.array(z.enum(['markdown', 'html', 'json', 'text'])).default(['json']), // 4.2.1: aligned with server.js MCP registration default; markdown remains opt-in via formats:['markdown'] for RAG workflows
   mode: z.enum(['sync', 'async']).default('sync'),
   webhook: z.object({
     url: z.string().url(),

package/src/tools/basic/extractText.js

@@ -1,15 +1,17 @@
 /**
  * extract_text — Extract clean text content from HTML.
  * Extracted from server.js inline handler.
+ * D3.1: Added output_format:"markdown" option backed by Turndown.
  */
 
 import { load } from 'cheerio';
 import { fetchWithTimeout } from './_fetch.js';
+import { htmlToMarkdown } from '../../utils/htmlToMarkdown.js';
 
 /**
- * @param {{ url: string, remove_scripts?: boolean, remove_styles?: boolean }} params
+ * @param {{ url: string, remove_scripts?: boolean, remove_styles?: boolean, output_format?: "text"|"markdown" }} params
  */
-export async function extractTextHandler({ url, remove_scripts, remove_styles }) {
+export async function extractTextHandler({ url, remove_scripts, remove_styles, output_format }) {
   try {
     const response = await fetchWithTimeout(url);
     if (!response.ok) {
@@ -26,15 +28,24 @@ export async function extractTextHandler({ url, remove_scripts, remove_styles })
 
     const text = $('body').text().replace(/\s+/g, ' ').trim();
 
+    const result = {
+      word_count: text.split(/\s+/).filter(w => w.length > 0).length,
+      char_count: text.length,
+      url: response.url
+    };
+
+    if (output_format === 'markdown') {
+      result.markdown = htmlToMarkdown($.html('body'));
+      result.output_format = 'markdown';
+    } else {
+      result.text = text;
+      result.output_format = 'text';
+    }
+
     return {
       content: [{
         type: 'text',
-        text: JSON.stringify({
-          text,
-          word_count: text.split(/\s+/).filter(w => w.length > 0).length,
-          char_count: text.length,
-          url: response.url
-        }, null, 2)
+        text: JSON.stringify(result, null, 2)
       }]
     };
   } catch (error) {

package/src/tools/crawl/crawlDeep.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { ElicitationHelper } from '../../core/ElicitationHelper.js'; // D1.4
 import { BFSCrawler } from '../../core/crawlers/BFSCrawler.js';
 import { DomainFilter } from '../../utils/domainFilter.js';
 import { CacheManager } from '../../core/cache/CacheManager.js';
@@ -87,6 +88,13 @@ export class CrawlDeepTool {
     this.timeout = timeout;
     // Per-session result cache: avoids redundant crawls of the same root URL
     this.cache = cacheEnabled ? new CacheManager({ ttl: cacheTTL }) : null;
+    // D1.4: Elicitation helper
+    this._elicitation = new ElicitationHelper({});
+  }
+
+  /** D1.4: Wire MCP server for elicitation. Call from server.js after instantiation. */
+  setMcpServer(mcpServer) {
+    this._elicitation = new ElicitationHelper({ mcpServer });
   }
 
   async execute(params) {
@@ -100,6 +108,25 @@ export class CrawlDeepTool {
         if (cached) return cached;
       }
 
+      // D1.4: Elicitation — warn when max_pages is very high
+      if (validated.max_pages > 500) {
+        const proceed = await this._elicitation.confirm(
+          `crawl_deep will crawl up to ${validated.max_pages} pages from ${validated.url}. Large crawls consume many credits.`,
+          {
+            url: validated.url,
+            max_pages: validated.max_pages,
+            max_depth: validated.max_depth,
+          }
+        );
+        if (!proceed) {
+          return {
+            success: false,
+            error: 'Crawl cancelled by user (elicitation declined).',
+            url: validated.url,
+          };
+        }
+      }
+
       // Create domain filter if configuration provided
       let domainFilter = null;
       if (validated.import_filter_config) {

package/src/tools/extract/extractContent.js

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { ContentProcessor } from '../../core/processing/ContentProcessor.js';
 import { BrowserProcessor } from '../../core/processing/BrowserProcessor.js';
 import { HTMLCleaner, ContentQualityAssessor } from '../../utils/contentUtils.js';
+import { htmlToMarkdown } from '../../utils/htmlToMarkdown.js'; // D3.1
 
 const ExtractContentSchema = z.object({
   url: z.string().url(),
@@ -294,25 +295,12 @@ export class ExtractContentTool {
   }
 
   /**
-   * Convert HTML content to Markdown
-   * @param {string} html - HTML content
-   * @returns {string} - Markdown content
+   * Convert HTML content to Markdown using Turndown (D3.1).
+   * @param {string} html
+   * @returns {string}
    */
   convertToMarkdown(html) {
-    // Simple HTML to Markdown conversion
-    return html
-      .replace(/<h([1-6])[^>]*>(.*?)<\/h[1-6]>/gi, (match, level, text) => {
-        const hashes = '#'.repeat(parseInt(level));
-        return `\n${hashes} ${text}\n`;
-      })
-      .replace(/<p[^>]*>(.*?)<\/p>/gi, '\n$1\n')
-      .replace(/<strong[^>]*>(.*?)<\/strong>/gi, '**$1**')
-      .replace(/<em[^>]*>(.*?)<\/em>/gi, '*$1*')
-      .replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, '[$2]($1)')
-      .replace(/<br[^>]*>/gi, '\n')
-      .replace(/<[^>]+>/g, '') // Remove remaining HTML tags
-      .replace(/\n{3,}/g, '\n\n') // Normalize line breaks
-      .trim();
+    return htmlToMarkdown(html);
   }
 
   /**

package/src/tools/extract/extractStructured.js

@@ -5,6 +5,7 @@
  */
 
 import { z } from 'zod';
+import { ElicitationHelper } from '../../core/ElicitationHelper.js'; // D1.4
 import { load } from 'cheerio';
 import { LLMManager } from '../../core/llm/LLMManager.js';
 import { fetchAndParse } from './_fetchAndParse.js';
@@ -30,6 +31,13 @@ export class ExtractStructuredTool {
     this.llmManager = null;
     this.llmConfig = options.llmConfig || {};
     this.userAgent = 'Mozilla/5.0 (compatible; CrawlForge-MCP/3.0; ExtractStructured)';
+    // D1.4: Elicitation helper
+    this._elicitation = new ElicitationHelper({});
+  }
+
+  /** D1.4: Wire MCP server for elicitation. */
+  setMcpServer(mcpServer) {
+    this._elicitation = new ElicitationHelper({ mcpServer });
   }
 
   /**