venombrowser 4.1.0

package/src/mcp-server.js

@@ -0,0 +1,101 @@
+/**
+ * VenomBrowser MCP Server — Kimi-style Model Context Protocol interface
+ *
+ * Implements MCP (JSON-RPC 2.0 over stdio) for agent integration.
+ * Communicates with daemon via single POST /command endpoint.
+ *
+ * v4.0.0 — Kimi-style architecture:
+ *   - Uses new bridge-client with Kimi-style protocol
+ *   - Screenshot returns as MCP image content (not base64 in text)
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  ListToolsRequestSchema,
+  CallToolRequestSchema
+} = require('@modelcontextprotocol/sdk/types.js');
+
+const { BrowserBridge } = require('./bridge-client');
+const { getMcpToolDefinitions, executeTool } = require('./tools/browser-tools');
+
+class VenomBrowserMcpServer {
+  constructor() {
+    const host = process.env.BRIDGE_HOST || '127.0.0.1';
+    const port = parseInt(process.env.BRIDGE_PORT || '10086', 10);
+    const session = process.env.BRIDGE_SESSION || 'mcp-session';
+
+    this.bridge = new BrowserBridge({ host, port, session });
+
+    this.server = new Server(
+      { name: 'venombrowser', version: '4.0.0' },
+      { capabilities: { tools: {} } }
+    );
+
+    this._registerHandlers();
+    this._registerErrorHandling();
+  }
+
+  _registerHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return { tools: getMcpToolDefinitions() };
+    });
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+
+      try {
+        const result = await executeTool(this.bridge, name, args || {});
+
+        // Special handling for screenshots — return as MCP image content
+        if (name === 'screenshot' && result.path) {
+          const fs = require('fs');
+          if (fs.existsSync(result.path)) {
+            const imageBuffer = fs.readFileSync(result.path);
+            const base64 = imageBuffer.toString('base64');
+            return {
+              content: [
+                { type: 'image', data: base64, mimeType: result.mimeType || 'image/png' },
+                { type: 'text', text: `Screenshot saved to ${result.path} (${result.sizeBytes} bytes)` }
+              ]
+            };
+          }
+        }
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: 'text', text: `Error: ${error.message}` }],
+          isError: true
+        };
+      }
+    });
+  }
+
+  _registerErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error('[VenomBrowser MCP] Server error:', error);
+    };
+
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+
+    process.on('SIGTERM', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  async start() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('[VenomBrowser MCP] Server started (stdio transport)');
+    console.error('[VenomBrowser MCP] Serving browser tools to connected agent');
+  }
+}
+
+module.exports = VenomBrowserMcpServer;

package/src/providers/index.js

@@ -0,0 +1,47 @@
+/**
+ * VenomBrowser LLM Provider Registry
+ *
+ * Factory pattern for pluggable LLM providers. All providers implement:
+ *   async chat(messages, tools) → { content, tool_calls }
+ *
+ * Config via environment variables:
+ *   LLM_PROVIDER    — "ollama" | "openrouter" (default: "openrouter")
+ *   + provider-specific vars (see individual provider files)
+ */
+
+const OllamaProvider   = require('./ollama');
+const OpenRouterProvider = require('./openrouter');
+
+const PROVIDERS = {
+  ollama: OllamaProvider,
+  openrouter: OpenRouterProvider
+};
+
+/**
+ * Create a provider instance based on config.
+ *
+ * @param {object} [opts] - Override options
+ * @param {string} [opts.provider] - Provider name (overrides LLM_PROVIDER env)
+ * @param {object} [opts.config]   - Provider-specific config (overrides env vars)
+ * @returns {object} Provider instance with .chat(messages, tools) method
+ */
+function createProvider(opts = {}) {
+  const name = (opts.provider || process.env.LLM_PROVIDER || 'openrouter').toLowerCase();
+
+  const ProviderClass = PROVIDERS[name];
+  if (!ProviderClass) {
+    const available = Object.keys(PROVIDERS).join(', ');
+    throw new Error(`Unknown LLM provider "${name}". Available: ${available}`);
+  }
+
+  return new ProviderClass(opts.config || {});
+}
+
+/**
+ * List available provider names.
+ */
+function listProviders() {
+  return Object.keys(PROVIDERS);
+}
+
+module.exports = { createProvider, listProviders };

package/src/providers/ollama.js

@@ -0,0 +1,108 @@
+/**
+ * VenomBrowser — Ollama Provider
+ *
+ * Talks to a local Ollama instance using /api/chat with tool calling.
+ *
+ * Config (env vars):
+ *   OLLAMA_HOST   — default http://localhost:11434
+ *   OLLAMA_MODEL  — default qwen2.5:7b
+ */
+
+const axios = require('axios');
+
+class OllamaProvider {
+  constructor(config = {}) {
+    this.host  = config.host  || process.env.OLLAMA_HOST  || 'http://localhost:11434';
+    this.model = config.model || process.env.OLLAMA_MODEL || 'qwen2.5:7b';
+    this.name  = 'ollama';
+  }
+
+  /**
+   * Send a chat completion request to Ollama.
+   *
+   * @param {Array} messages - Chat messages array
+   * @param {Array} tools    - Tool definitions (OpenAI format)
+   * @returns {Promise<{content: string|null, tool_calls: Array|null}>}
+   */
+  async chat(messages, tools = []) {
+    const payload = {
+      model: this.model,
+      messages,
+      stream: false
+    };
+
+    // Only include tools if provided — some Ollama models don't support them
+    if (tools && tools.length > 0) {
+      payload.tools = tools;
+    }
+
+    const res = await axios.post(`${this.host}/api/chat`, payload, {
+      timeout: 120000
+    });
+
+    const msg = res.data.message;
+
+    // Normalize Ollama's response to our standard format
+    return {
+      content: msg.content || null,
+      tool_calls: this._normalizeToolCalls(msg.tool_calls)
+    };
+  }
+
+  /**
+   * Check if Ollama is running and the model is available.
+   */
+  async healthCheck() {
+    const checks = { running: false, model_available: false, model: this.model };
+
+    try {
+      await axios.get(`${this.host}/api/version`, { timeout: 5000 });
+      checks.running = true;
+    } catch {
+      throw new Error(`Ollama not running on ${this.host}. Start it with: ollama serve`);
+    }
+
+    try {
+      const models = await axios.get(`${this.host}/api/tags`, { timeout: 10000 });
+      const available = models.data.models.map(m => m.name);
+      checks.model_available = available.includes(this.model);
+
+      if (!checks.model_available) {
+        throw new Error(
+          `Model ${this.model} not available. Available: ${available.join(', ')}. ` +
+          `Pull it with: ollama pull ${this.model}`
+        );
+      }
+    } catch (err) {
+      if (err.message.includes('not available') || err.message.includes('not running')) throw err;
+      throw new Error(`Could not check Ollama models: ${err.message}`);
+    }
+
+    return checks;
+  }
+
+  /**
+   * Normalize Ollama tool_calls to standard format.
+   * Ollama sometimes returns arguments as string, sometimes as object.
+   */
+  _normalizeToolCalls(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) return null;
+
+    return toolCalls.map(call => ({
+      id: call.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      type: 'function',
+      function: {
+        name: call.function.name,
+        arguments: typeof call.function.arguments === 'string'
+          ? JSON.parse(call.function.arguments)
+          : call.function.arguments || {}
+      }
+    }));
+  }
+
+  toString() {
+    return `OllamaProvider(${this.host}, model=${this.model})`;
+  }
+}
+
+module.exports = OllamaProvider;

package/src/providers/openrouter.js

@@ -0,0 +1,158 @@
+/**
+ * VenomBrowser — OpenRouter Provider
+ *
+ * Talks to OpenRouter's OpenAI-compatible API for chat completions with
+ * tool calling. Works with both free and paid models.
+ *
+ * Config (env vars):
+ *   OPENROUTER_API_KEY  — your sk-or-v1-... key (required)
+ *   OPENROUTER_MODEL    — model slug, default meta-llama/llama-4-maverick:free
+ */
+
+const axios = require('axios');
+
+const OPENROUTER_BASE = 'https://openrouter.ai/api/v1';
+
+class OpenRouterProvider {
+  constructor(config = {}) {
+    this.apiKey = config.apiKey || process.env.OPENROUTER_API_KEY;
+    this.model  = config.model  || process.env.OPENROUTER_MODEL || 'meta-llama/llama-4-maverick:free';
+    this.name   = 'openrouter';
+
+    if (!this.apiKey) {
+      throw new Error(
+        'OPENROUTER_API_KEY is required. Get a free key at https://openrouter.ai/keys'
+      );
+    }
+
+    this.http = axios.create({
+      baseURL: OPENROUTER_BASE,
+      timeout: 120000,
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://github.com/TechVenom/VenomBrowser',
+        'X-Title': 'VenomBrowser Browser Agent'
+      }
+    });
+  }
+
+  /**
+   * Send a chat completion request to OpenRouter.
+   *
+   * @param {Array} messages - Chat messages array
+   * @param {Array} tools    - Tool definitions (OpenAI format)
+   * @returns {Promise<{content: string|null, tool_calls: Array|null}>}
+   */
+  async chat(messages, tools = []) {
+    const payload = {
+      model: this.model,
+      messages: this._normalizeMessages(messages),
+      stream: false
+    };
+
+    // Only include tools if provided
+    if (tools && tools.length > 0) {
+      payload.tools = tools;
+      payload.tool_choice = 'auto';
+    }
+
+    const res = await this.http.post('/chat/completions', payload);
+    const choice = res.data.choices?.[0];
+
+    if (!choice) {
+      throw new Error('OpenRouter returned no choices');
+    }
+
+    const msg = choice.message;
+
+    return {
+      content: msg.content || null,
+      tool_calls: this._normalizeToolCalls(msg.tool_calls)
+    };
+  }
+
+  /**
+   * Check if OpenRouter is reachable and the API key is valid.
+   */
+  async healthCheck() {
+    const checks = { reachable: false, key_valid: false, model: this.model };
+
+    try {
+      // OpenRouter doesn't have a dedicated health endpoint, but we can
+      // hit /models to verify the key works and the model exists.
+      const res = await this.http.get('/models', { timeout: 10000 });
+      checks.reachable = true;
+      checks.key_valid = true;
+
+      // Check if our model is in the list
+      const models = res.data.data || [];
+      const found = models.find(m => m.id === this.model);
+      if (!found) {
+        // Model might still work even if not in the first page of results
+        // (OpenRouter has many models), so just warn
+        console.warn(`[OpenRouter] Model ${this.model} not found in model list — it may still work.`);
+      }
+    } catch (err) {
+      if (err.response?.status === 401) {
+        throw new Error('Invalid OpenRouter API key. Check OPENROUTER_API_KEY.');
+      }
+      throw new Error(`OpenRouter unreachable: ${err.message}`);
+    }
+
+    return checks;
+  }
+
+  /**
+   * Normalize messages for OpenRouter compatibility.
+   * OpenRouter uses OpenAI's format, but we need to ensure tool results
+   * are properly formatted.
+   */
+  _normalizeMessages(messages) {
+    return messages.map(msg => {
+      // Tool results need to have tool_call_id in OpenAI format
+      if (msg.role === 'tool') {
+        return {
+          role: 'tool',
+          tool_call_id: msg.tool_call_id || msg.name || 'unknown',
+          content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+        };
+      }
+
+      // Assistant messages with tool_calls
+      if (msg.role === 'assistant' && msg.tool_calls) {
+        return {
+          role: 'assistant',
+          content: msg.content || null,
+          tool_calls: msg.tool_calls
+        };
+      }
+
+      return msg;
+    });
+  }
+
+  /**
+   * Normalize OpenRouter/OpenAI tool_calls to standard format.
+   */
+  _normalizeToolCalls(toolCalls) {
+    if (!toolCalls || toolCalls.length === 0) return null;
+
+    return toolCalls.map(call => ({
+      id: call.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      type: 'function',
+      function: {
+        name: call.function.name,
+        arguments: typeof call.function.arguments === 'string'
+          ? JSON.parse(call.function.arguments)
+          : call.function.arguments || {}
+      }
+    }));
+  }
+
+  toString() {
+    return `OpenRouterProvider(model=${this.model})`;
+  }
+}
+
+module.exports = OpenRouterProvider;