brave-real-browser-mcp-server 2.34.0 → 2.35.0

package/dist/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Brave Real Browser MCP Server - Distribution Entry Point
+ * 
+ * This file redirects to the actual MCP server implementation
+ */
+
+require('../src/mcp/index.js');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.34.0",
+  "version": "2.35.0",
   "description": "MCP Server for Brave Real Browser - Puppeteer with Brave Browser, Stealth Mode, Ad Blocker, and Turnstile Auto-Solver for undetectable web automation.",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.mjs",
@@ -22,12 +22,14 @@
     "node": ">=18.0.0"
   },
   "bin": {
-    "brave-mcp": "./src/mcp/index.js"
+    "brave-mcp": "./dist/index.js",
+    "brave-lsp": "./src/lsp/index.js"
   },
   "scripts": {
     "dev": "node src/mcp/index.js",
     "mcp": "node src/mcp/index.js",
     "mcp:verbose": "node src/mcp/index.js --verbose",
+    "lsp": "node src/lsp/index.js",
     "build": "echo 'Root package uses pre-built lib/ - no build needed'",
     "build:self": "echo 'Root package uses pre-built lib/ - no build needed'",
     "test": "npm run cjs_test && npm run esm_test",
@@ -65,11 +67,13 @@
   "license": "ISC",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "brave-real-puppeteer-core": "^24.49.0",
+    "brave-real-puppeteer-core": "^24.50.0",
     "ghost-cursor": "^1.4.2",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
     "tree-kill": "^1.2.2",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
     "xvfb": "^0.4.0"
   },
   "devDependencies": {

package/packages/brave-real-blocker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-blocker",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Advanced uBlock Origin management and stealth features for Brave Real Browser",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -63,7 +63,7 @@
     "@types/adm-zip": "^0.5.5",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.0.0",
-    "brave-real-puppeteer-core": "^24.49.0",
+    "brave-real-puppeteer-core": "^24.50.0",
     "mocha": "^10.4.0",
     "puppeteer-core": "^24.35.0",
     "sinon": "^17.0.1",

package/packages/brave-real-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-launcher",
-  "version": "1.16.0",
+  "version": "1.17.0",
   "description": "Launch Brave Browser with ease from node. Based on chrome-launcher with Brave-specific support.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -54,7 +54,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "brave-real-blocker": "^1.10.0",
+    "brave-real-blocker": "^1.11.0",
     "escape-string-regexp": "^4.0.0",
     "is-wsl": "^2.2.0",
     "which": "^4.0.0"

package/packages/brave-real-puppeteer-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-puppeteer-core",
-  "version": "24.49.0",
+  "version": "24.50.0",
   "description": "🦁 Brave Real-World Optimized Puppeteer & Playwright Core with 1-5ms ultra-fast timing, 50+ professional stealth features, intelligent browser auto-detection, and 100% bot detection bypass. Features cross-platform Brave browser integration, comprehensive anti-detection, and breakthrough performance improvements.",
   "keywords": [
     "automation",
@@ -132,7 +132,7 @@
     "test-version": "node ./scripts/test-version-management.js"
   },
   "dependencies": {
-    "brave-real-launcher": "^1.16.0",
+    "brave-real-launcher": "^1.17.0",
     "get-east-asian-width": "^1.4.0",
     "yargs": "^18.0.0"
   },

package/src/lsp/capabilities/autocomplete.js

@@ -0,0 +1,102 @@
+/**
+ * Autocomplete Capability
+ */
+const { CompletionItemKind, InsertTextFormat } = require('vscode-languageserver/node');
+
+function getCompletions(document, position, tools, lang, settings) {
+  const text = document.getText();
+  const offset = document.offsetAt(position);
+  const lineText = text.split('\n')[position.line] || '';
+  const prefix = getPrefix(lineText, position.character);
+  const completions = [];
+  const context = detectContext(text, offset);
+
+  if (context.type === 'tool_name' || context.type === 'start') {
+    for (const tool of tools) {
+      const toolLang = lang.tools[tool.name] || {};
+      if (tool.name.toLowerCase().startsWith(prefix) || prefix === '') {
+        completions.push({
+          label: tool.name,
+          kind: CompletionItemKind.Function,
+          detail: `${tool.emoji} ${toolLang.detail || tool.description}`,
+          documentation: toolLang.documentation || tool.description,
+          insertText: generateToolSnippet(tool),
+          insertTextFormat: InsertTextFormat.Snippet,
+          data: { toolName: tool.name },
+          sortText: `0_${tool.name}`,
+        });
+      }
+    }
+  }
+
+  if (context.type === 'parameter_name') {
+    const tool = tools.find(t => t.name === context.toolName);
+    if (tool?.inputSchema?.properties) {
+      const toolLang = lang.tools[tool.name] || {};
+      for (const [name, schema] of Object.entries(tool.inputSchema.properties)) {
+        if (name.toLowerCase().startsWith(prefix) || prefix === '') {
+          completions.push({
+            label: name,
+            kind: CompletionItemKind.Property,
+            detail: schema.type,
+            documentation: toolLang.parameters?.[name] || schema.description,
+            insertText: `${name}: `,
+            sortText: tool.inputSchema.required?.includes(name) ? `0_${name}` : `1_${name}`,
+          });
+        }
+      }
+    }
+  }
+
+  if (context.type === 'parameter_value') {
+    const tool = tools.find(t => t.name === context.toolName);
+    const schema = tool?.inputSchema?.properties?.[context.paramName];
+    if (schema?.enum) {
+      for (const value of schema.enum) {
+        completions.push({ label: value, kind: CompletionItemKind.EnumMember, insertText: `'${value}'` });
+      }
+    }
+    if (schema?.type === 'boolean') {
+      completions.push({ label: 'true', kind: CompletionItemKind.Keyword }, { label: 'false', kind: CompletionItemKind.Keyword });
+    }
+  }
+
+  return completions;
+}
+
+function generateToolSnippet(tool) {
+  const required = tool.inputSchema.required || [];
+  const props = tool.inputSchema.properties || {};
+  if (required.length === 0) return `${tool.name}()`;
+  let i = 1;
+  const params = required.map(p => {
+    const prop = props[p];
+    if (prop?.type === 'string') return `${p}: '\${${i++}}'`;
+    if (prop?.type === 'boolean') return `${p}: \${${i++}:false}`;
+    if (prop?.type === 'number') return `${p}: \${${i++}:0}`;
+    return `${p}: \${${i++}}`;
+  });
+  return `${tool.name}({ ${params.join(', ')} })`;
+}
+
+function getPrefix(line, char) {
+  let start = char;
+  while (start > 0 && /\w/.test(line[start - 1])) start--;
+  return line.substring(start, char).toLowerCase();
+}
+
+function detectContext(text, offset) {
+  const before = text.substring(0, offset);
+  if (/(\w+)\s*\(\s*\{[^}]*(\w+)\s*:\s*['"]?$/.test(before)) {
+    const match = before.match(/(\w+)\s*\(\s*\{[^}]*(\w+)\s*:\s*['"]?$/);
+    return { type: 'parameter_value', toolName: match[1], paramName: match[2] };
+  }
+  if (/(\w+)\s*\(\s*\{[^}]*$/.test(before)) {
+    const match = before.match(/(\w+)\s*\(\s*\{[^}]*$/);
+    return { type: 'parameter_name', toolName: match[1] };
+  }
+  if (/(?:await\s+|^\s*)$/.test(before)) return { type: 'tool_name' };
+  return { type: 'start' };
+}
+
+module.exports = { getCompletions };

package/src/lsp/capabilities/diagnostics.js

@@ -0,0 +1,42 @@
+/**
+ * Diagnostics Capability
+ */
+const { DiagnosticSeverity } = require('vscode-languageserver/node');
+
+function getDiagnostics(document, tools, lang, maxDiagnostics = 100) {
+  const text = document.getText();
+  const diagnostics = [];
+  let browserInit = false, browserClosed = false;
+  const browserRequired = ['navigate','get_content','wait','click','type','solve_captcha','random_scroll','find_element','save_content_as_markdown','search_regex','extract_json','scrape_meta_tags','press_key','deep_analysis','network_recorder','link_harvester','cookie_manager','iframe_handler','stream_extractor','js_scrape','execute_js','player_api_hook','form_automator'];
+  const toolNames = tools.map(t => t.name);
+  const regex = new RegExp(`(${toolNames.join('|')})\\s*\\(`, 'g');
+  const lines = text.split('\n');
+  
+  for (let i = 0; i < lines.length && diagnostics.length < maxDiagnostics; i++) {
+    const line = lines[i];
+    let match;
+    while ((match = regex.exec(line)) !== null) {
+      const name = match[1];
+      const range = { start: { line: i, character: match.index }, end: { line: i, character: match.index + name.length } };
+      
+      if (name === 'browser_init') { browserInit = true; browserClosed = false; }
+      if (name === 'browser_close') browserClosed = true;
+      
+      if (browserRequired.includes(name) && !browserInit) {
+        diagnostics.push({ severity: DiagnosticSeverity.Error, range, message: lang.diagnostics?.browserNotInit || 'Browser not initialized', source: 'brave-real-browser', code: 'browser-not-init' });
+      }
+      if (browserRequired.includes(name) && browserClosed) {
+        diagnostics.push({ severity: DiagnosticSeverity.Error, range, message: 'Browser already closed', source: 'brave-real-browser', code: 'browser-closed' });
+      }
+    }
+    regex.lastIndex = 0;
+  }
+  
+  if (browserInit && !browserClosed) {
+    diagnostics.push({ severity: DiagnosticSeverity.Information, range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }, message: 'Consider adding browser_close() at the end', source: 'brave-real-browser', code: 'missing-cleanup' });
+  }
+  
+  return diagnostics;
+}
+
+module.exports = { getDiagnostics };

package/src/lsp/capabilities/hover.js

@@ -0,0 +1,65 @@
+/**
+ * Hover Capability
+ */
+const { MarkupKind } = require('vscode-languageserver/node');
+
+function getHoverInfo(document, position, tools, lang) {
+  const text = document.getText();
+  const lineText = text.split('\n')[position.line] || '';
+  const word = getWordAtPosition(lineText, position.character);
+  if (!word) return null;
+
+  const tool = tools.find(t => t.name === word);
+  if (tool) {
+    const toolLang = lang.tools[tool.name] || {};
+    const props = tool.inputSchema.properties || {};
+    const required = tool.inputSchema.required || [];
+    const paramDocs = Object.entries(props).map(([name, schema]) => {
+      const isReq = required.includes(name);
+      const desc = toolLang.parameters?.[name] || schema.description || '';
+      return `| \`${name}\` | ${schema.type} | ${isReq ? '✅' : '❌'} | ${desc} |`;
+    });
+
+    return {
+      contents: {
+        kind: MarkupKind.Markdown,
+        value: [
+          `## ${tool.emoji} ${toolLang.label || tool.name}`,
+          '', toolLang.documentation || tool.description, '',
+          '### Parameters', '', '| Name | Type | Required | Description |', '|------|------|----------|-------------|',
+          ...paramDocs, '',
+          '### Example', '', '```javascript', generateExample(tool), '```'
+        ].join('\n'),
+      },
+    };
+  }
+  return null;
+}
+
+function generateExample(tool) {
+  const props = tool.inputSchema.properties || {};
+  const required = tool.inputSchema.required || [];
+  if (required.length === 0) return `await ${tool.name}();`;
+  const params = required.map(p => {
+    const prop = props[p];
+    let val = prop?.default;
+    if (val === undefined) {
+      if (prop?.type === 'string') val = "'value'";
+      else if (prop?.type === 'boolean') val = 'true';
+      else if (prop?.type === 'number') val = '1000';
+      else if (prop?.enum) val = `'${prop.enum[0]}'`;
+      else val = '{}';
+    } else if (typeof val === 'string') val = `'${val}'`;
+    return `  ${p}: ${val}`;
+  });
+  return `await ${tool.name}({\n${params.join(',\n')}\n});`;
+}
+
+function getWordAtPosition(line, char) {
+  let start = char, end = char;
+  while (start > 0 && /\w/.test(line[start - 1])) start--;
+  while (end < line.length && /\w/.test(line[end])) end++;
+  return start === end ? null : line.substring(start, end);
+}
+
+module.exports = { getHoverInfo };

package/src/lsp/capabilities/refactoring.js

@@ -0,0 +1,23 @@
+/**
+ * Refactoring Capability
+ */
+const { CodeActionKind } = require('vscode-languageserver/node');
+
+function getRefactorings(document, range, context, tools, lang) {
+  const actions = [];
+  for (const diag of context.diagnostics || []) {
+    if (diag.code === 'browser-not-init') {
+      actions.push({ title: 'Add browser_init() at start', kind: CodeActionKind.QuickFix, diagnostics: [diag], edit: { changes: { [document.uri]: [{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }, newText: "await browser_init({ headless: false });\n\n" }] } } });
+    }
+    if (diag.code === 'missing-cleanup') {
+      const lastLine = document.lineCount - 1;
+      actions.push({ title: 'Add browser_close() at end', kind: CodeActionKind.QuickFix, diagnostics: [diag], edit: { changes: { [document.uri]: [{ range: { start: { line: lastLine, character: 9999 }, end: { line: lastLine, character: 9999 } }, newText: "\n\nawait browser_close();" }] } } });
+    }
+  }
+  const selectedText = document.getText(range);
+  if (selectedText.includes('await')) {
+    actions.push({ title: 'Wrap in try-catch', kind: CodeActionKind.RefactorRewrite, edit: { changes: { [document.uri]: [{ range, newText: `try {\n  ${selectedText.split('\n').join('\n  ')}\n} catch (error) {\n  console.error(error);\n}` }] } } });
+  }
+  return actions;
+}
+module.exports = { getRefactorings };

package/src/lsp/capabilities/simulation.js

@@ -0,0 +1,31 @@
+/**
+ * Workflow Simulation Capability
+ */
+function simulateWorkflow(document, tools, lang, execute = false) {
+  const text = document.getText();
+  const codeLenses = [];
+  const toolNames = tools.map(t => t.name);
+  const regex = new RegExp(`(${toolNames.join('|')})\\s*\\(`, 'g');
+  const lines = text.split('\n');
+  let stepCount = 0;
+  
+  for (let i = 0; i < lines.length; i++) {
+    let match;
+    while ((match = regex.exec(lines[i])) !== null) {
+      stepCount++;
+      const tool = tools.find(t => t.name === match[1]);
+      codeLenses.push({
+        range: { start: { line: i, character: match.index }, end: { line: i, character: match.index + match[1].length } },
+        command: { title: `${tool?.emoji || '▶️'} Step ${stepCount}`, command: 'braveRealBrowser.stepDetails', arguments: [match[1], i] }
+      });
+    }
+    regex.lastIndex = 0;
+  }
+  
+  if (stepCount > 0) {
+    codeLenses.unshift({ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }, command: { title: `▶️ Run Simulation (${stepCount} steps)`, command: 'braveRealBrowser.runSimulation', arguments: [document.uri] } });
+  }
+  
+  return codeLenses;
+}
+module.exports = { simulateWorkflow };

package/src/lsp/capabilities/snippets.js

@@ -0,0 +1,13 @@
+/**
+ * Snippets Capability
+ */
+function getSnippets(category, tools, lang) {
+  const snippets = {
+    basic: [{ name: 'basic-workflow', prefix: 'brave-basic', description: lang.snippets?.basicFlow || 'Basic flow', body: ["await browser_init({ headless: ${1:false} });","await navigate({ url: '${2:https://example.com}' });","${0}","await browser_close();"] }],
+    login: [{ name: 'login-flow', prefix: 'brave-login', description: lang.snippets?.loginFlow || 'Login flow', body: ["await browser_init({ headless: false, turnstile: true });","await navigate({ url: '${1:https://example.com/login}' });","await type({ selector: '${2:input[name=\"email\"]}', text: '${3:user@example.com}' });","await type({ selector: '${4:input[name=\"password\"]}', text: '${5:password}' });","await click({ selector: '${6:button[type=\"submit\"]}', humanLike: true });","${0}"] }],
+    scraping: [{ name: 'scrape-flow', prefix: 'brave-scrape', description: lang.snippets?.scrapeFlow || 'Scraping', body: ["await browser_init({ headless: true });","await navigate({ url: '${1:https://example.com}' });","const content = await get_content({ format: '${2:text}' });","const links = await link_harvester({ types: ['all'] });","${0}","await browser_close();"] }],
+    captcha: [{ name: 'captcha-flow', prefix: 'brave-captcha', description: lang.snippets?.captchaFlow || 'CAPTCHA', body: ["await browser_init({ headless: false, turnstile: true });","await navigate({ url: '${1:https://site-with-captcha.com}' });","await solve_captcha({ type: 'auto', timeout: 30000 });","${0}"] }],
+  };
+  return category && snippets[category] ? snippets[category] : Object.values(snippets).flat();
+}
+module.exports = { getSnippets };

package/src/lsp/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * Brave Real Browser LSP Server - Entry Point
+ */
+const colors = { reset: '\x1b[0m', bright: '\x1b[1m', dim: '\x1b[2m', green: '\x1b[32m', yellow: '\x1b[33m', blue: '\x1b[34m', magenta: '\x1b[35m', cyan: '\x1b[36m' };
+
+function displayBanner() {
+  console.error('');
+  console.error(`${colors.bright}${colors.cyan}╔════════════════════════════════════════════════════════════╗${colors.reset}`);
+  console.error(`${colors.bright}${colors.cyan}║${colors.reset}  ${colors.bright}${colors.magenta}🦁 Brave Real Browser LSP Server${colors.reset}                         ${colors.cyan}║${colors.reset}`);
+  console.error(`${colors.bright}${colors.cyan}║${colors.reset}  ${colors.dim}Language Server Protocol for IDE Intelligence${colors.reset}              ${colors.cyan}║${colors.reset}`);
+  console.error(`${colors.bright}${colors.cyan}╚════════════════════════════════════════════════════════════╝${colors.reset}`);
+  console.error('');
+  console.error(`${colors.bright}${colors.green}🎯 Capabilities:${colors.reset}`);
+  const caps = [['✨ Autocomplete', 'Tool names, parameters, values'],['📖 Hover', 'Documentation on hover'],['⚠️  Diagnostics', 'Error & warning detection'],['📝 Snippets', 'Code templates & workflows'],['🔧 Refactoring', 'Quick fixes & code actions'],['🎬 Simulation', 'Workflow simulation in IDE'],['🌍 Multi-language', 'English & Hindi support']];
+  for (const [n, d] of caps) console.error(`  ${colors.yellow}${n.padEnd(20)}${colors.reset}${colors.dim}${d}${colors.reset}`);
+  console.error('');
+  console.error(`${colors.bright}${colors.blue}🔗 Transport:${colors.reset} STDIO`);
+  console.error(`${colors.bright}${colors.green}Starting LSP Server...${colors.reset}`);
+  console.error('');
+}
+
+if (!process.stdin.isTTY) { require('./server.js'); } 
+else { displayBanner(); require('./server.js'); }

package/src/lsp/languages/en.js

@@ -0,0 +1,66 @@
+/**
+ * English Language Pack for LSP
+ */
+
+module.exports = {
+  tools: {
+    browser_init: {
+      label: 'Initialize Browser',
+      detail: 'Start Brave browser with stealth mode',
+      documentation: 'Launches Brave browser with anti-detection features, ad blocker, and optional proxy support.',
+      parameters: {
+        headless: 'Run browser without visible window',
+        proxy: 'Proxy server configuration',
+        turnstile: 'Enable Cloudflare Turnstile auto-solver',
+        enableBlocker: 'Enable ad/tracker blocking'
+      }
+    },
+    navigate: { label: 'Navigate to URL', detail: 'Go to a specific webpage', documentation: 'Navigates the browser to the specified URL.', parameters: { url: 'The URL to navigate to', waitUntil: 'When to consider navigation complete', timeout: 'Maximum wait time' } },
+    get_content: { label: 'Get Page Content', detail: 'Extract content from page', documentation: 'Gets the page content in specified format.', parameters: { format: 'Output format', selector: 'CSS selector' } },
+    wait: { label: 'Wait', detail: 'Wait for element or timeout', documentation: 'Pauses execution until condition is met.', parameters: { type: 'Wait type', value: 'Selector or timeout', timeout: 'Maximum wait' } },
+    click: { label: 'Click Element', detail: 'Click with human-like behavior', documentation: 'Clicks on an element using ghost-cursor.', parameters: { selector: 'Element selector', humanLike: 'Use realistic movement', clickCount: 'Number of clicks', delay: 'Click delay' } },
+    type: { label: 'Type Text', detail: 'Type into input field', documentation: 'Types text with realistic keystroke delays.', parameters: { selector: 'Input selector', text: 'Text to type', delay: 'Keystroke delay', clear: 'Clear first' } },
+    browser_close: { label: 'Close Browser', detail: 'Close and cleanup', documentation: 'Closes the browser.', parameters: { force: 'Force close' } },
+    solve_captcha: { label: 'Solve CAPTCHA', detail: 'Auto-solve CAPTCHAs', documentation: 'Automatically solves Turnstile, reCAPTCHA, hCaptcha.', parameters: { type: 'CAPTCHA type', timeout: 'Max solve time' } },
+    random_scroll: { label: 'Random Scroll', detail: 'Human-like scrolling', documentation: 'Scrolls with human-like behavior.', parameters: { direction: 'Scroll direction', amount: 'Scroll amount', smooth: 'Smooth scrolling' } },
+    find_element: { label: 'Find Element', detail: 'Locate elements', documentation: 'Finds elements by selector/xpath/text.', parameters: { selector: 'CSS selector', xpath: 'XPath', text: 'Text content', multiple: 'Return all' } },
+    save_content_as_markdown: { label: 'Save as Markdown', detail: 'Export to MD', documentation: 'Saves page as Markdown file.', parameters: { filename: 'Output filename', selector: 'Content selector', includeImages: 'Include images', includeMeta: 'Include meta' } },
+    redirect_tracer: { label: 'Trace Redirects', detail: 'Follow redirects', documentation: 'Traces redirects to final destination.', parameters: { url: 'URL to trace', maxRedirects: 'Max redirects', includeHeaders: 'Include headers' } },
+    search_regex: { label: 'Regex Search', detail: 'Search with patterns', documentation: 'Searches content using regex.', parameters: { pattern: 'Regex pattern', flags: 'Regex flags', source: 'Search source' } },
+    extract_json: { label: 'Extract JSON', detail: 'Get JSON data', documentation: 'Extracts JSON from page/scripts.', parameters: { source: 'Data source', selector: 'CSS selector', jsonPath: 'JSONPath' } },
+    scrape_meta_tags: { label: 'Scrape Meta Tags', detail: 'Get meta data', documentation: 'Extracts meta, OG, Twitter data.', parameters: { types: 'Tag types' } },
+    press_key: { label: 'Press Key', detail: 'Keyboard input', documentation: 'Presses keyboard keys.', parameters: { key: 'Key to press', modifiers: 'Modifier keys', count: 'Press count' } },
+    progress_tracker: { label: 'Track Progress', detail: 'Monitor automation', documentation: 'Tracks automation progress.', parameters: { action: 'Action type', taskName: 'Task name', progress: 'Progress %' } },
+    deep_analysis: { label: 'Deep Analysis', detail: 'Page analysis', documentation: 'Analyzes SEO, performance, accessibility.', parameters: { types: 'Analysis types', detailed: 'Detailed info' } },
+    network_recorder: { label: 'Record Network', detail: 'Capture requests', documentation: 'Records network requests.', parameters: { action: 'Action', filter: 'Request filter' } },
+    link_harvester: { label: 'Harvest Links', detail: 'Extract links', documentation: 'Extracts all links from page.', parameters: { types: 'Link types', selector: 'Container', includeText: 'Include text' } },
+    cookie_manager: { label: 'Manage Cookies', detail: 'Cookie operations', documentation: 'Manages browser cookies.', parameters: { action: 'Action', name: 'Cookie name', value: 'Cookie value', domain: 'Domain' } },
+    file_downloader: { label: 'Download File', detail: 'Download from URL', documentation: 'Downloads files.', parameters: { url: 'File URL', filename: 'Output name', directory: 'Output dir' } },
+    iframe_handler: { label: 'Handle iFrame', detail: 'iFrame operations', documentation: 'Handles iFrame content.', parameters: { action: 'Action', selector: 'iFrame selector', index: 'iFrame index' } },
+    stream_extractor: { label: 'Extract Streams', detail: 'Get video/audio', documentation: 'Extracts stream URLs.', parameters: { types: 'Stream types', quality: 'Quality' } },
+    js_scrape: { label: 'JS Scrape', detail: 'Scrape JS content', documentation: 'Scrapes JS-rendered content.', parameters: { selector: 'CSS selector', waitForJS: 'Wait for JS', timeout: 'Max wait' } },
+    execute_js: { label: 'Execute JS', detail: 'Run JavaScript', documentation: 'Executes custom JavaScript.', parameters: { code: 'JS code', returnValue: 'Return result' } },
+    player_api_hook: { label: 'Player API Hook', detail: 'Video player control', documentation: 'Hooks into video players.', parameters: { playerType: 'Player type', action: 'Action' } },
+    form_automator: { label: 'Automate Form', detail: 'Fill and submit', documentation: 'Auto-fills and submits forms.', parameters: { selector: 'Form selector', data: 'Form data', submit: 'Submit', humanLike: 'Human delays' } }
+  },
+  diagnostics: {
+    browserNotInit: 'Browser not initialized. Call browser_init first.',
+    invalidSelector: 'Invalid CSS selector syntax.',
+    missingUrl: 'URL is required.',
+    invalidUrl: 'Invalid URL format.',
+    timeoutTooLong: 'Timeout exceeds maximum.',
+    missingRequired: 'Required parameter is missing.',
+    invalidJson: 'Invalid JSON syntax.',
+    selectorNotFound: 'Element not found.',
+    unknownTool: 'Unknown tool name.',
+    deprecatedTool: 'This tool is deprecated.'
+  },
+  snippets: {
+    basicFlow: 'Basic browser automation flow',
+    loginFlow: 'Login automation with form fill',
+    scrapeFlow: 'Web scraping workflow',
+    captchaFlow: 'CAPTCHA solving workflow',
+    downloadFlow: 'File download automation'
+  },
+  ui: { autocompletePlaceholder: 'Type tool name...', noSuggestions: 'No suggestions', loading: 'Loading...', error: 'Error', warning: 'Warning', info: 'Info' }
+};

package/src/lsp/languages/hi.js

@@ -0,0 +1,50 @@
+/**
+ * Hindi Language Pack for LSP - हिंदी भाषा पैक
+ */
+
+module.exports = {
+  tools: {
+    browser_init: { label: 'ब्राउज़र शुरू करें', detail: 'Brave ब्राउज़र स्टेल्थ मोड में', documentation: 'Brave ब्राउज़र को एंटी-डिटेक्शन के साथ लॉन्च करता है।', parameters: { headless: 'बिना विंडो चलाएं', proxy: 'प्रॉक्सी कॉन्फ़िगरेशन', turnstile: 'Turnstile ऑटो-सॉल्वर', enableBlocker: 'एड ब्लॉकिंग' } },
+    navigate: { label: 'URL पर जाएं', detail: 'वेबपेज पर जाएं', documentation: 'ब्राउज़र को URL पर ले जाता है।', parameters: { url: 'जाने का URL', waitUntil: 'नेविगेशन पूरा कब', timeout: 'अधिकतम समय' } },
+    get_content: { label: 'कंटेंट लें', detail: 'पेज से कंटेंट', documentation: 'पेज कंटेंट प्राप्त करता है।', parameters: { format: 'फॉर्मेट', selector: 'CSS selector' } },
+    wait: { label: 'इंतजार करें', detail: 'एलीमेंट का इंतजार', documentation: 'शर्त पूरी होने तक रुकता है।', parameters: { type: 'इंतजार प्रकार', value: 'Selector या समय', timeout: 'अधिकतम' } },
+    click: { label: 'क्लिक करें', detail: 'मानव-जैसा क्लिक', documentation: 'ghost-cursor से क्लिक करता है।', parameters: { selector: 'एलीमेंट selector', humanLike: 'वास्तविक मूवमेंट', clickCount: 'क्लिक संख्या', delay: 'देरी' } },
+    type: { label: 'टाइप करें', detail: 'इनपुट में टाइप', documentation: 'वास्तविक कीस्ट्रोक के साथ टाइप करता है।', parameters: { selector: 'इनपुट selector', text: 'टेक्स्ट', delay: 'कीस्ट्रोक देरी', clear: 'पहले साफ करें' } },
+    browser_close: { label: 'ब्राउज़र बंद करें', detail: 'बंद और क्लीनअप', documentation: 'ब्राउज़र बंद करता है।', parameters: { force: 'फोर्स क्लोज़' } },
+    solve_captcha: { label: 'CAPTCHA हल करें', detail: 'ऑटो-सॉल्व', documentation: 'Turnstile, reCAPTCHA हल करता है।', parameters: { type: 'CAPTCHA प्रकार', timeout: 'अधिकतम समय' } },
+    random_scroll: { label: 'रैंडम स्क्रॉल', detail: 'मानव-जैसा स्क्रॉल', documentation: 'रैंडम स्क्रॉल करता है।', parameters: { direction: 'दिशा', amount: 'मात्रा', smooth: 'स्मूथ' } },
+    find_element: { label: 'एलीमेंट खोजें', detail: 'पेज पर खोजें', documentation: 'selector/xpath से खोजता है।', parameters: { selector: 'CSS selector', xpath: 'XPath', text: 'टेक्स्ट', multiple: 'सभी लौटाएं' } },
+    save_content_as_markdown: { label: 'MD में सेव', detail: 'Markdown एक्सपोर्ट', documentation: 'Markdown फाइल में सेव करता है।', parameters: { filename: 'फाइलनेम', selector: 'कंटेंट selector', includeImages: 'इमेज शामिल', includeMeta: 'मेटा शामिल' } },
+    redirect_tracer: { label: 'रीडायरेक्ट ट्रेस', detail: 'रीडायरेक्ट फॉलो', documentation: 'सभी रीडायरेक्ट ट्रेस करता है।', parameters: { url: 'ट्रेस URL', maxRedirects: 'अधिकतम', includeHeaders: 'हेडर शामिल' } },
+    search_regex: { label: 'Regex सर्च', detail: 'पैटर्न से खोज', documentation: 'regex से खोजता है।', parameters: { pattern: 'पैटर्न', flags: 'फ्लैग्स', source: 'सोर्स' } },
+    extract_json: { label: 'JSON निकालें', detail: 'JSON डेटा', documentation: 'JSON निकालता है।', parameters: { source: 'सोर्स', selector: 'selector', jsonPath: 'JSONPath' } },
+    scrape_meta_tags: { label: 'Meta Tags', detail: 'मेटा डेटा', documentation: 'Meta, OG, Twitter डेटा।', parameters: { types: 'प्रकार' } },
+    press_key: { label: 'की प्रेस', detail: 'कीबोर्ड इनपुट', documentation: 'की प्रेस करता है।', parameters: { key: 'की', modifiers: 'मॉडिफायर', count: 'संख्या' } },
+    progress_tracker: { label: 'प्रोग्रेस ट्रैक', detail: 'ऑटोमेशन मॉनिटर', documentation: 'प्रोग्रेस ट्रैक करता है।', parameters: { action: 'एक्शन', taskName: 'टास्क नाम', progress: 'प्रतिशत' } },
+    deep_analysis: { label: 'गहरा विश्लेषण', detail: 'पेज विश्लेषण', documentation: 'SEO, परफॉर्मेंस विश्लेषण।', parameters: { types: 'प्रकार', detailed: 'विस्तृत' } },
+    network_recorder: { label: 'नेटवर्क रिकॉर्ड', detail: 'रिक्वेस्ट कैप्चर', documentation: 'नेटवर्क रिकॉर्ड करता है।', parameters: { action: 'एक्शन', filter: 'फ़िल्टर' } },
+    link_harvester: { label: 'लिंक्स निकालें', detail: 'सभी लिंक्स', documentation: 'सभी लिंक्स निकालता है।', parameters: { types: 'प्रकार', selector: 'कंटेनर', includeText: 'टेक्स्ट शामिल' } },
+    cookie_manager: { label: 'कुकीज़ मैनेज', detail: 'कुकी ऑपरेशन', documentation: 'कुकीज़ मैनेज करता है।', parameters: { action: 'एक्शन', name: 'नाम', value: 'वैल्यू', domain: 'डोमेन' } },
+    file_downloader: { label: 'फाइल डाउनलोड', detail: 'URL से डाउनलोड', documentation: 'फाइल्स डाउनलोड करता है।', parameters: { url: 'फाइल URL', filename: 'नाम', directory: 'डायरेक्टरी' } },
+    iframe_handler: { label: 'iFrame हैंडल', detail: 'iFrame ऑपरेशन', documentation: 'iFrame हैंडल करता है।', parameters: { action: 'एक्शन', selector: 'selector', index: 'इंडेक्स' } },
+    stream_extractor: { label: 'स्ट्रीम निकालें', detail: 'वीडियो/ऑडियो URL', documentation: 'स्ट्रीम URLs निकालता है।', parameters: { types: 'प्रकार', quality: 'क्वालिटी' } },
+    js_scrape: { label: 'JS स्क्रैप', detail: 'JS कंटेंट', documentation: 'JS-रेंडर्ड कंटेंट।', parameters: { selector: 'selector', waitForJS: 'JS इंतजार', timeout: 'अधिकतम' } },
+    execute_js: { label: 'JS चलाएं', detail: 'JavaScript रन', documentation: 'कस्टम JS चलाता है।', parameters: { code: 'कोड', returnValue: 'रिज़ल्ट लौटाएं' } },
+    player_api_hook: { label: 'Player Hook', detail: 'वीडियो प्लेयर', documentation: 'प्लेयर में हुक करता है।', parameters: { playerType: 'प्लेयर', action: 'एक्शन' } },
+    form_automator: { label: 'फॉर्म ऑटोमेट', detail: 'फॉर्म भरें', documentation: 'फॉर्म भरता और सबमिट करता है।', parameters: { selector: 'फॉर्म selector', data: 'डेटा', submit: 'सबमिट', humanLike: 'मानव देरी' } }
+  },
+  diagnostics: {
+    browserNotInit: 'ब्राउज़र इनिशियलाइज़ नहीं। पहले browser_init करें।',
+    invalidSelector: 'अमान्य CSS selector।',
+    missingUrl: 'URL आवश्यक है।',
+    invalidUrl: 'अमान्य URL फॉर्मेट।',
+    timeoutTooLong: 'टाइमआउट बहुत लंबा।',
+    missingRequired: 'आवश्यक पैरामीटर गायब।',
+    invalidJson: 'अमान्य JSON।',
+    selectorNotFound: 'एलीमेंट नहीं मिला।',
+    unknownTool: 'अज्ञात टूल।',
+    deprecatedTool: 'यह टूल deprecated है।'
+  },
+  snippets: { basicFlow: 'बेसिक ऑटोमेशन', loginFlow: 'लॉगिन ऑटोमेशन', scrapeFlow: 'स्क्रैपिंग वर्कफ्लो', captchaFlow: 'CAPTCHA वर्कफ्लो', downloadFlow: 'डाउनलोड ऑटोमेशन' },
+  ui: { autocompletePlaceholder: 'टूल टाइप करें...', noSuggestions: 'कोई सुझाव नहीं', loading: 'लोड हो रहा...', error: 'त्रुटि', warning: 'चेतावनी', info: 'जानकारी' }
+};

package/src/lsp/server.js

@@ -0,0 +1,78 @@
+/**
+ * Brave Real Browser LSP Server
+ */
+const { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, MarkupKind } = require('vscode-languageserver/node');
+const { TextDocument } = require('vscode-languageserver-textdocument');
+const { TOOLS } = require('../mcp/tools.js');
+const { getCompletions } = require('./capabilities/autocomplete.js');
+const { getHoverInfo } = require('./capabilities/hover.js');
+const { getDiagnostics } = require('./capabilities/diagnostics.js');
+const { getSnippets } = require('./capabilities/snippets.js');
+const { getRefactorings } = require('./capabilities/refactoring.js');
+const { simulateWorkflow } = require('./capabilities/simulation.js');
+const { getLanguagePack } = require('./utils/i18n.js');
+
+const connection = createConnection(ProposedFeatures.all, process.stdin, process.stdout);
+const documents = new TextDocuments(TextDocument);
+let settings = { language: 'en', maxDiagnostics: 100, enableSnippets: true, enableSimulation: true, enableRefactoring: true };
+
+connection.onInitialize(() => ({
+  capabilities: {
+    textDocumentSync: TextDocumentSyncKind.Incremental,
+    completionProvider: { resolveProvider: true, triggerCharacters: ['.', "'", '"', '(', '{', ' '] },
+    hoverProvider: true,
+    codeActionProvider: true,
+    codeLensProvider: { resolveProvider: true },
+    signatureHelpProvider: { triggerCharacters: ['(', ','] },
+    documentSymbolProvider: true,
+  },
+}));
+
+connection.onDidChangeConfiguration((change) => {
+  if (change.settings?.braveRealBrowser) settings = { ...settings, ...change.settings.braveRealBrowser };
+  documents.all().forEach(validateDocument);
+});
+
+connection.onCompletion((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  return doc ? getCompletions(doc, params.position, TOOLS, getLanguagePack(settings.language), settings) : [];
+});
+
+connection.onCompletionResolve((item) => {
+  const lang = getLanguagePack(settings.language);
+  const tool = TOOLS.find(t => t.name === item.data?.toolName);
+  if (tool && lang.tools[tool.name]) {
+    const tl = lang.tools[tool.name];
+    item.documentation = { kind: MarkupKind.Markdown, value: `### ${tool.emoji} ${tl.label}\n\n${tl.documentation}\n\n**Parameters:**\n${Object.entries(tl.parameters || {}).map(([k, v]) => `- \`${k}\`: ${v}`).join('\n')}` };
+  }
+  return item;
+});
+
+connection.onHover((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  return doc ? getHoverInfo(doc, params.position, TOOLS, getLanguagePack(settings.language)) : null;
+});
+
+function validateDocument(doc) {
+  connection.sendDiagnostics({ uri: doc.uri, diagnostics: getDiagnostics(doc, TOOLS, getLanguagePack(settings.language), settings.maxDiagnostics) });
+}
+
+documents.onDidChangeContent((change) => validateDocument(change.document));
+
+connection.onCodeAction((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  return doc ? getRefactorings(doc, params.range, params.context, TOOLS, getLanguagePack(settings.language)) : [];
+});
+
+connection.onCodeLens((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  return doc ? simulateWorkflow(doc, TOOLS, getLanguagePack(settings.language)) : [];
+});
+
+connection.onCodeLensResolve((lens) => lens);
+
+connection.onRequest('braveRealBrowser/snippets', (params) => getSnippets(params?.category, TOOLS, getLanguagePack(settings.language)));
+
+documents.listen(connection);
+connection.listen();
+console.error('🦁 Brave Real Browser LSP Server started');

package/src/lsp/utils/i18n.js

@@ -0,0 +1,29 @@
+/**
+ * Internationalization Utility
+ */
+const en = require('../languages/en.js');
+const hi = require('../languages/hi.js');
+const languagePacks = { en, hi, english: en, hindi: hi };
+
+function getLanguagePack(langCode) {
+  return languagePacks[(langCode || 'en').toLowerCase()] || languagePacks.en;
+}
+
+function getAvailableLanguages() {
+  return [
+    { code: 'en', name: 'English', nativeName: 'English' },
+    { code: 'hi', name: 'Hindi', nativeName: 'हिंदी' },
+  ];
+}
+
+function translate(langCode, key, fallback = '') {
+  const lang = getLanguagePack(langCode);
+  let value = lang;
+  for (const k of key.split('.')) {
+    value = value?.[k];
+    if (value === undefined) break;
+  }
+  return value || fallback;
+}
+
+module.exports = { getLanguagePack, getAvailableLanguages, translate };