osai-agent 4.0.0

package/src/tools/mcp-client.js

@@ -0,0 +1,209 @@
+import { Client, StdioClientTransport, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
+import { logger } from '../utils/logger.js';
+
+class McpConnection {
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+    this.client = null;
+    this.transport = null;
+    this.tools = [];
+    this.connected = false;
+  }
+
+  async connect() {
+    const { transport: type, command, args, url, env } = this.config;
+
+    if (type === 'http' || type === 'streamable-http') {
+      const transportOpts = this.config.headers
+        ? { requestInit: { headers: this.config.headers } }
+        : undefined;
+      this.transport = new StreamableHTTPClientTransport(new URL(url), transportOpts);
+    } else {
+      this.transport = new StdioClientTransport({
+        command,
+        args: args || [],
+        env: { ...(env || {}) },
+        stderr: 'pipe',
+      });
+    }
+
+    this.client = new Client({
+      name: 'osai-agent',
+      version: '4.0.0',
+    });
+
+    await this.client.connect(this.transport);
+    this.connected = true;
+
+    const result = await this.client.listTools();
+    this.tools = result.tools || [];
+    logger.debug(`MCP server "${this.name}": ${this.tools.length} tools available`);
+
+    return this.tools;
+  }
+
+  async disconnect() {
+    this.connected = false;
+    if (this.transport) {
+      try { await this.transport.close(); } catch {}
+    }
+    this.client = null;
+    this.transport = null;
+    this.tools = [];
+  }
+
+  async callTool(toolName, args = {}) {
+    if (!this.connected || !this.client) {
+      throw new Error(`MCP server "${this.name}" is not connected`);
+    }
+    const result = await this.client.callTool({
+      name: toolName,
+      arguments: args,
+    });
+    return result;
+  }
+
+  getTool(toolName) {
+    return this.tools.find(t => t.name === toolName) || null;
+  }
+}
+
+export class McpClientManager {
+  constructor() {
+    this.connections = new Map();
+    this.toolIndex = new Map();
+  }
+
+  async addServer(name, config) {
+    if (this.connections.has(name)) {
+      await this.removeServer(name);
+    }
+
+    const conn = new McpConnection(name, config);
+    try {
+      const tools = await conn.connect();
+      this.connections.set(name, conn);
+
+      for (const tool of tools) {
+        const key = `${name}:${tool.name}`;
+        this.toolIndex.set(key, { serverName: name, toolDef: tool });
+      }
+
+      logger.info(`MCP server "${name}" connected with ${tools.length} tools`);
+      return tools;
+    } catch (err) {
+      logger.error(`Failed to connect MCP server "${name}": ${err.message}`);
+      try { await conn.disconnect(); } catch {}
+      throw err;
+    }
+  }
+
+  async removeServer(name) {
+    const conn = this.connections.get(name);
+    if (!conn) return;
+
+    for (const tool of conn.tools) {
+      const key = `${name}:${tool.name}`;
+      this.toolIndex.delete(key);
+    }
+
+    await conn.disconnect();
+    this.connections.delete(name);
+    logger.info(`MCP server "${name}" disconnected`);
+  }
+
+  async executeTool(serverName, toolName, params = {}) {
+    const conn = this.connections.get(serverName);
+    if (!conn) {
+      return { success: false, output: '', error: `MCP server "${serverName}" not found` };
+    }
+    try {
+      const result = await conn.callTool(toolName, params);
+      const output = (result.content || [])
+        .map(c => c.text || JSON.stringify(c))
+        .join('\n');
+      return { success: true, output, isError: !!result.isError };
+    } catch (err) {
+      return { success: false, output: '', error: err.message };
+    }
+  }
+
+  getToolDescriptions() {
+    const descriptions = [];
+    for (const [name, conn] of this.connections) {
+      for (const tool of conn.tools) {
+        descriptions.push({
+          server: name,
+          mcpTool: tool.name,
+          description: tool.description || '',
+          inputSchema: tool.inputSchema || {},
+        });
+      }
+    }
+    return descriptions;
+  }
+
+  listServers() {
+    const result = [];
+    for (const [name, conn] of this.connections) {
+      result.push({
+        name,
+        connected: conn.connected,
+        tools: conn.tools.map(t => ({
+          name: t.name,
+          description: t.description || '',
+        })),
+        config: { ...conn.config },
+      });
+    }
+    return result;
+  }
+
+  getServer(name) {
+    return this.connections.get(name) || null;
+  }
+
+  async loadFromConfig(config) {
+    const servers = config || {};
+    const names = Object.keys(servers);
+    if (names.length === 0) return;
+
+    logger.info(`Loading ${names.length} MCP server(s) from config`);
+    const results = { connected: [], failed: [] };
+
+    for (const name of names) {
+      try {
+        const tools = await this.addServer(name, servers[name]);
+        results.connected.push({ name, toolCount: tools.length });
+      } catch (err) {
+        results.failed.push({ name, error: err.message });
+      }
+    }
+
+    if (results.failed.length > 0) {
+      logger.warn('MCP server connection failures:', results.failed);
+    }
+    return results;
+  }
+
+  async reload(config) {
+    const currentNames = Array.from(this.connections.keys());
+    for (const name of currentNames) {
+      await this.removeServer(name);
+    }
+    return this.loadFromConfig(config);
+  }
+
+  disconnectAll() {
+    for (const name of Array.from(this.connections.keys())) {
+      this.removeServer(name).catch(() => {});
+    }
+  }
+
+  getToolByKey(key) {
+    return this.toolIndex.get(key) || null;
+  }
+}
+
+export const mcpClientManager = new McpClientManager();

package/src/tools/registry.js

@@ -0,0 +1,132 @@
+// =============================================================================
+// OS AI Agent — Tool Registry
+// =============================================================================
+// Central registry for all tools the agent can use. Each tool is an independent
+// module with a standard interface: name, description, parameters, execute(),
+// and safety tier.
+// =============================================================================
+
+import { logger } from '../utils/logger.js';
+import { TOOLS, SAFETY_TIERS } from '../utils/constants.js';
+import { browse, searchAndBrowse, extractStructuredData } from './browser.js';
+
+/**
+ * Represents a single tool that the agent can invoke
+ */
+class Tool {
+  /**
+   * @param {Object} opts
+   * @param {string} opts.name - Tool identifier (e.g. TOOLS.LOCAL_CMD)
+   * @param {string} opts.description - Human-readable description
+   * @param {Array} opts.parameters - Parameter schema
+   * @param {Function} opts.execute - Async execution function
+   * @param {string} opts.safety - Default safety tier
+   */
+  constructor({ name, description, parameters, execute, safety }) {
+    this.name = name;
+    this.description = description || '';
+    this.parameters = parameters || [];
+    this.execute = execute;
+    this.safety = safety || SAFETY_TIERS.WRITE;
+  }
+}
+
+/**
+ * Central tool registry — register, discover, and execute tools
+ */
+export class ToolRegistry {
+  constructor() {
+    this.tools = new Map();
+  }
+
+  /** Register a new tool */
+  register(toolDefinition) {
+    const tool = toolDefinition instanceof Tool
+      ? toolDefinition
+      : new Tool(toolDefinition);
+    this.tools.set(tool.name, tool);
+    logger.debug(`Tool registered: ${tool.name}`);
+  }
+
+  /** Get a tool by name */
+  get(name) {
+    return this.tools.get(name) || null;
+  }
+
+  /** List all registered tools */
+  list() {
+    return Array.from(this.tools.values());
+  }
+
+  /** List all tool names */
+  listNames() {
+    return Array.from(this.tools.keys());
+  }
+
+  /** Check if a tool is registered */
+  has(name) {
+    return this.tools.has(name);
+  }
+
+  /** Execute a tool by name with given parameters and context */
+  async execute(name, params, context = {}) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      throw new Error(`Unknown tool: ${name}`);
+    }
+    logger.debug(`Executing tool: ${name}`, { params });
+    try {
+      const result = await tool.execute(params, context);
+      return result;
+    } catch (error) {
+      logger.error(`Tool execution failed: ${name}`, { error: error.message });
+      return { success: false, output: '', error: error.message };
+    }
+  }
+
+  /** Get the safety tier of a tool */
+  getSafetyTier(name) {
+    const tool = this.tools.get(name);
+    return tool ? tool.safety : SAFETY_TIERS.WRITE;
+  }
+
+  /** Get tool descriptions for prompt generation */
+  getToolDescriptions() {
+    return this.list().map(t => ({
+      name: t.name,
+      description: t.description,
+      safety: t.safety,
+    }));
+  }
+}
+
+/** Global singleton registry */
+export const registry = new ToolRegistry();
+
+// Register browser tools
+registry.register({
+  name: TOOLS.BROWSE,
+  description: 'Open a URL in a headless browser and extract readable text content. Falls back to HTTP fetch if Playwright is unavailable.',
+  parameters: [{ name: 'url', type: 'string', required: true, description: 'The http/https URL to browse' }],
+  execute: async (params) => await browse(params.url),
+  safety: SAFETY_TIERS.READ,
+});
+
+registry.register({
+  name: TOOLS.BROWSE_SEARCH,
+  description: 'Search the web using DuckDuckGo, then open the first result and extract its content.',
+  parameters: [{ name: 'query', type: 'string', required: true, description: 'The search query' }],
+  execute: async (params) => await searchAndBrowse(params.query),
+  safety: SAFETY_TIERS.READ,
+});
+
+registry.register({
+  name: TOOLS.BROWSE_EXTRACT,
+  description: 'Navigate to a URL and extract specific DOM elements using CSS selectors.',
+  parameters: [
+    { name: 'url', type: 'string', required: true, description: 'The http/https URL' },
+    { name: 'selectors', type: 'object', required: true, description: 'Map of key → CSS selector' },
+  ],
+  execute: async (params) => await extractStructuredData(params.selectors, params.url),
+  safety: SAFETY_TIERS.READ,
+});

package/src/tools/search-providers.js

@@ -0,0 +1,237 @@
+import ddg from 'duck-duck-scrape';
+import { getJson } from 'serpapi';
+import { tavily } from '@tavily/core';
+import Conf from 'conf';
+import { logger } from '../utils/logger.js';
+
+const SEARCH_TIMEOUT = 15000;
+
+const parseKeys = (envVar) => (envVar || '')
+  .split(',')
+  .map(k => k.trim())
+  .filter(Boolean);
+
+const createKeyRotator = (keys) => {
+  let index = 0;
+  return {
+    keys,
+    hasKeys: keys.length > 0,
+    getNext() {
+      if (keys.length === 0) return null;
+      const key = keys[index % keys.length];
+      index++;
+      return key;
+    },
+    count: keys.length,
+  };
+};
+
+function getConfKeys(provider) {
+  try {
+    const config = new Conf({ projectName: 'osai-agent' });
+    const searchKeys = config.get('searchApiKeys', {});
+    return searchKeys[provider] || null;
+  } catch {
+    return null;
+  }
+}
+
+function getSearchKeys(provider) {
+  const envVarName = provider === 'serpapi' ? 'SERPAPI_API_KEY' : 'TAVILY_API_KEYS';
+  const envKeys = parseKeys(process.env[envVarName]);
+  if (envKeys.length > 0) return envKeys;
+  const confKey = getConfKeys(provider);
+  if (confKey) return [confKey];
+  return [];
+}
+
+const serpapiRotator = createKeyRotator(getSearchKeys('serpapi'));
+const tavilyRotator = createKeyRotator(getSearchKeys('tavily'));
+
+export async function searchDDG(query, maxResults = 5) {
+  const searchResults = await ddg.search(query, { maxResults });
+  if (!searchResults || !searchResults.results || searchResults.results.length === 0) {
+    throw new Error('DDG: no results');
+  }
+  return searchResults.results.slice(0, maxResults).map(r => ({
+    title: r.title || '',
+    url: r.href || r.url || '',
+    snippet: r.description || r.snippet || '',
+  }));
+}
+
+export async function searchSerpAPI(query, maxResults = 5) {
+  if (!serpapiRotator.hasKeys) throw new Error('SerpAPI: no API keys configured');
+
+  let lastError = null;
+  const maxAttempts = Math.min(serpapiRotator.count, 3);
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const apiKey = serpapiRotator.getNext();
+    try {
+      const response = await getJson({
+        engine: 'google',
+        api_key: apiKey,
+        q: query,
+        num: maxResults,
+      });
+      const results = (response.organic_results || []).slice(0, maxResults).map(r => ({
+        title: r.title || '',
+        url: r.link || r.url || '',
+        snippet: r.snippet || '',
+      }));
+      if (results.length > 0) return results;
+      lastError = new Error('SerpAPI: empty results');
+    } catch (err) {
+      lastError = err;
+      logger.debug(`SerpAPI key failed (attempt ${attempt + 1}): ${err.message}`);
+    }
+  }
+  throw lastError || new Error('SerpAPI: all keys failed');
+}
+
+export async function searchTavily(query, maxResults = 5) {
+  if (!tavilyRotator.hasKeys) throw new Error('Tavily: no API keys configured');
+
+  let lastError = null;
+  const maxAttempts = Math.min(tavilyRotator.count, 3);
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const apiKey = tavilyRotator.getNext();
+    try {
+      const tvly = tavily({ apiKey });
+      const response = await tvly.search(query, {
+        maxResults,
+        searchDepth: 'basic',
+      });
+      const results = (response.results || []).slice(0, maxResults).map(r => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.content || r.description || '',
+      }));
+      if (results.length > 0) return results;
+      lastError = new Error('Tavily: empty results');
+    } catch (err) {
+      lastError = err;
+      logger.debug(`Tavily key failed (attempt ${attempt + 1}): ${err.message}`);
+    }
+  }
+  throw lastError || new Error('Tavily: all keys failed');
+}
+
+export async function searchDDGHttp(query, maxResults = 5) {
+  const encoded = encodeURIComponent(query);
+  const BROWSER_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36',
+    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+    'Accept-Language': 'en-US,en;q=0.9',
+  };
+
+  const stripHtml = (html) => html
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x27;/g, "'")
+    .replace(/&#x2F;/g, '/').replace(/&#(\d+);/g, (_, c) => String.fromCharCode(parseInt(c)))
+    .replace(/&nbsp;/g, ' ').replace(/&copy;/g, '(c)').replace(/&reg;/g, '(r)')
+    .replace(/\s+([.,;:!?)])/g, '$1').replace(/\s{2,}/g, ' ').trim();
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SEARCH_TIMEOUT);
+
+  try {
+    const res = await fetch(`https://html.duckduckgo.com/html/?q=${encoded}`, {
+      headers: BROWSER_HEADERS,
+      signal: controller.signal,
+      redirect: 'follow',
+    });
+    clearTimeout(timer);
+
+    if (!res.ok) throw new Error(`DDG HTTP: ${res.status}`);
+
+    const html = await res.text();
+    const results = [];
+
+    const resultBlocks = html.split(/<div\s+class="result[\s"]/i);
+    for (const block of resultBlocks.slice(1, maxResults + 1)) {
+      const titleMatch = block.match(/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+      const snippetMatch = block.match(/<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i)
+        || block.match(/<td[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/td>/i);
+
+      if (titleMatch) {
+        let url = titleMatch[1].replace(/&amp;/g, '&');
+        const uddgMatch = url.match(/uddg=([^&]+)/);
+        if (uddgMatch) url = decodeURIComponent(uddgMatch[1]);
+        if (url && !url.includes('duckduckgo.com') && (url.startsWith('http') || url.startsWith('//'))) {
+          if (url.startsWith('//')) url = 'https:' + url;
+          results.push({
+            title: stripHtml(titleMatch[2]),
+            url,
+            snippet: snippetMatch ? stripHtml(snippetMatch[1]) : '',
+          });
+        }
+      }
+    }
+
+    if (results.length > 0) return results;
+    if (results.length === 0) {
+      const rows = html.match(/<tr[^>]*>[\s\S]*?<\/tr>/gi) || [];
+      let currentLink = null;
+      for (const row of rows) {
+        const linkMatch = row.match(/<a[^>]+class="result-link"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i)
+          || row.match(/<a[^>]+href="([^"]+)"[^>]*class="result-link"[^>]*>([\s\S]*?)<\/a>/i)
+          || row.match(/<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+        const snippetMatch = row.match(/<td[^>]*class="result-snippet"[^>]*>([\s\S]*?)<\/td>/i)
+          || row.match(/<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
+
+        if (linkMatch) {
+          let url = linkMatch[1].replace(/&amp;/g, '&');
+          const uddgMatch = url.match(/uddg=([^&]+)/);
+          if (uddgMatch) url = decodeURIComponent(uddgMatch[1]);
+          if (url && !url.includes('duckduckgo.com') && (url.startsWith('http') || url.startsWith('//'))) {
+            if (url.startsWith('//')) url = 'https:' + url;
+            currentLink = { url, title: stripHtml(linkMatch[2]), snippet: '' };
+            if (snippetMatch) {
+              currentLink.snippet = stripHtml(snippetMatch[1]);
+              results.push(currentLink);
+              currentLink = null;
+            }
+          }
+        } else if (currentLink && snippetMatch) {
+          currentLink.snippet = stripHtml(snippetMatch[1]);
+          results.push(currentLink);
+          currentLink = null;
+        }
+        if (results.length >= maxResults) break;
+      }
+    }
+
+    if (results.length === 0) throw new Error('DDG HTTP: no results parsed');
+    return results;
+  } catch (err) {
+    clearTimeout(timer);
+    throw err;
+  }
+}
+
+export function formatSearchOutput(query, results) {
+  const topResults = results.slice(0, 5);
+  const formatted = topResults.map((r, i) =>
+    `[${i + 1}] ${r.title}\n    URL: ${r.url}\n    ${r.snippet || 'No description'}`
+  ).join('\n\n');
+  return {
+    success: true,
+    output: `Web Search: "${query.trim()}"\nFound ${topResults.length} results:\n\n${formatted}\n\nTip: Use FETCH_URL to read the full content of any URL.`,
+    error: null,
+    results: topResults,
+  };
+}
+
+export function getProviderStatus() {
+  return {
+    ddg: { available: true, type: 'scrape' },
+    serpapi: { available: serpapiRotator.hasKeys, keyCount: serpapiRotator.count, type: 'api' },
+    tavily: { available: tavilyRotator.hasKeys, keyCount: tavilyRotator.count, type: 'api' },
+  };
+}

package/src/tools/ssh.js

@@ -0,0 +1,74 @@
+// =============================================================================
+// OS AI Agent — SSH Tool (Connection Pool + Dispatch)
+// =============================================================================
+import { connectSSH, execSSH, closeSSH } from '../services/ssh.js';
+import { logger } from '../utils/logger.js';
+
+/** Connection pool keyed by "host:port" */
+const connections = new Map();
+
+/**
+ * Execute a command on a remote device via SSH.
+ * Reuses connections from the pool when available.
+ */
+export const executeSSH = async (device, command) => {
+  const deviceKey = `${device.ip}:${device.port || 22}`;
+  const auth = device.auth_decrypted || {};
+
+  if (!auth.username) {
+    return { success: false, output: '', error: 'No SSH username configured for this device' };
+  }
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const connParams = {
+      host: device.ip,
+      port: device.port || 22,
+      username: auth.username,
+      password: auth.password,
+      privateKey: auth.privateKey || null,
+    };
+
+    try {
+      let conn = connections.get(deviceKey);
+      if (!conn) {
+        conn = await connectSSH(connParams, device.type);
+        connections.set(deviceKey, conn);
+      }
+
+      const result = await execSSH(conn, command);
+      return {
+        success: result.status === 'success',
+        output: result.output,
+        error: result.status === 'error' ? result.output : null,
+      };
+    } catch (error) {
+      connections.delete(deviceKey);
+      if (attempt >= 1) {
+        logger.error('SSH execution failed', { device: deviceKey, error: error.message });
+        return { success: false, output: '', error: error.message };
+      }
+    }
+  }
+};
+
+/**
+ * Close all pooled SSH connections
+ */
+export const closeAllConnections = () => {
+  for (const [key] of connections.entries()) {
+    try {
+      closeSSH(key.split(':')[0]);
+    } catch {
+      // Connection may already be closed
+    }
+  }
+  connections.clear();
+};
+
+/**
+ * Get connection pool status
+ */
+export const getConnectionStatus = () => ({
+  active: connections.size,
+  devices: Array.from(connections.keys()),
+});