nexus-mcp-agent 0.1.2

package/src/tools/system/index.ts

@@ -0,0 +1,140 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger } from '../../core/logger.js';
+import { nexusConfig } from '../../core/config.js';
+
+const log = createContextLogger('tools/system');
+
+const SENSITIVE_KEYS = ['OPENAI_API_KEY', 'ANTHROPIC_API_KEY', 'BRAVE_SEARCH_API_KEY', 'NEXUS_CONFIG'];
+
+async function systemInfoFull(): Promise<any> {
+  const os = await import('os');
+  return {
+    nexus: {
+      name: 'NEXUS',
+      version: '0.1.0',
+      uptime: process.uptime(),
+      memory: process.memoryUsage(),
+    },
+    system: {
+      platform: process.platform,
+      arch: process.arch,
+      nodeVersion: process.version,
+      hostname: os.hostname(),
+      uptime: os.uptime(),
+      cpus: os.cpus().length,
+      totalMemory: os.totalmem(),
+      freeMemory: os.freemem(),
+    },
+    config: {
+      llmProvider: nexusConfig.llm.provider,
+      llmModel: nexusConfig.llm.model,
+      searchProvider: nexusConfig.search.provider,
+      vectorDb: nexusConfig.vector.type,
+      allowedDirs: nexusConfig.security.allowedDirs,
+    },
+  };
+}
+
+const ConfigGetSchema = z.object({
+  key: z.string().optional(),
+});
+
+const ConfigSetSchema = z.object({
+  key: z.string(),
+  value: z.any(),
+});
+
+const EnvReadSchema = z.object({
+  key: z.string().optional(),
+});
+
+type ConfigGetParams = z.infer<typeof ConfigGetSchema>;
+type ConfigSetParams = z.infer<typeof ConfigSetSchema>;
+type EnvReadParams = z.infer<typeof EnvReadSchema>;
+
+async function configGet(params: ConfigGetParams): Promise<any> {
+  if (!params.key) return { success: true, config: nexusConfig };
+  const keys = params.key.split('.');
+  let val: any = nexusConfig;
+  for (const k of keys) {
+    if (val && typeof val === 'object' && k in val) val = val[k];
+    else return { success: false, error: `Key not found: ${params.key}` };
+  }
+  return { success: true, key: params.key, value: val };
+}
+
+async function configSet(params: ConfigSetParams): Promise<any> {
+  const { key, value } = params;
+  const keys = key.split('.');
+  let obj: any = nexusConfig;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!obj[keys[i]] || typeof obj[keys[i]] !== 'object') {
+      return { success: false, error: `Invalid key path: ${key}` };
+    }
+    obj = obj[keys[i]];
+  }
+  obj[keys[keys.length - 1]] = value;
+  log.info(`Config updated: ${key} = ${JSON.stringify(value)}`);
+  return { success: true, key, value };
+}
+
+async function envRead(params: EnvReadParams): Promise<any> {
+  if (!params.key) {
+    const env: Record<string, string | undefined> = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (!SENSITIVE_KEYS.includes(k)) {
+        env[k] = v;
+      }
+    }
+    return { success: true, env, filteredKeys: SENSITIVE_KEYS };
+  }
+  if (SENSITIVE_KEYS.includes(params.key)) {
+    return { success: false, error: `Access denied: ${params.key} is a sensitive key` };
+  }
+  return { success: true, key: params.key, value: process.env[params.key] };
+}
+
+async function ping(): Promise<any> {
+  return { success: true, pong: true, timestamp: new Date().toISOString(), uptime: process.uptime() };
+}
+
+export function registerSystemTools(server: McpServer, registry: ToolRegistry): void {
+  server.tool('system_info_full', 'Get detailed system information', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await systemInfoFull(), null, 2) }],
+  }));
+
+  server.registerTool('config_get', {
+    description: 'Get configuration value',
+    inputSchema: ConfigGetSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await configGet(params), null, 2) }],
+  }));
+
+  server.registerTool('config_set', {
+    description: 'Set configuration value',
+    inputSchema: ConfigSetSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await configSet(params), null, 2) }],
+  }));
+
+  server.registerTool('env_read', {
+    description: 'Read environment variable (sensitive keys filtered)',
+    inputSchema: EnvReadSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await envRead(params), null, 2) }],
+  }));
+
+  server.tool('ping', 'Health check', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await ping(), null, 2) }],
+  }));
+
+  registry.register({ name: 'system_info_full', category: 'system', description: 'System info', handler: systemInfoFull });
+  registry.register({ name: 'config_get', category: 'system', description: 'Get config', handler: configGet });
+  registry.register({ name: 'config_set', category: 'system', description: 'Set config', handler: configSet });
+  registry.register({ name: 'env_read', category: 'system', description: 'Read env var', handler: envRead });
+  registry.register({ name: 'ping', category: 'system', description: 'Health check', handler: ping });
+
+  log.info('Registered 5 system tools');
+}

package/src/tools/terminal/index.ts

@@ -0,0 +1,105 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import { exec as execCb } from 'child_process';
+import { promisify } from 'util';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger, logAudit } from '../../core/logger.js';
+import { nexusConfig } from '../../core/config.js';
+
+const exec = promisify(execCb);
+const log = createContextLogger('tools/terminal');
+
+function isCommandBlocked(command: string): boolean {
+  return nexusConfig.security.blockedCommands.some(blocked =>
+    command.toLowerCase().includes(blocked.toLowerCase())
+  );
+}
+
+const ShellExecSchema = z.object({
+  command: z.string().describe('Command to execute'),
+  cwd: z.string().optional().describe('Working directory'),
+  timeout: z.number().optional().default(30000).describe('Timeout in ms'),
+  env: z.record(z.string()).optional().describe('Environment variables'),
+});
+
+type ShellExecParams = z.infer<typeof ShellExecSchema>;
+
+async function shellExec(params: ShellExecParams): Promise<any> {
+  const { command, cwd, timeout = 30000, env = {} } = params;
+
+  if (isCommandBlocked(command)) {
+    logAudit('shell_exec_blocked', { command });
+    return { success: false, error: `Command blocked by security policy: ${command}` };
+  }
+
+  logAudit('shell_exec', { command, cwd });
+  log.info(`Executing: ${command}`);
+
+  try {
+    const { stdout, stderr } = await exec(command, {
+      cwd,
+      timeout,
+      env: { ...process.env as any, ...env },
+      maxBuffer: 10 * 1024 * 1024,
+    });
+
+    return { success: true, stdout, stderr, exitCode: 0 };
+  } catch (error: any) {
+    return {
+      success: false,
+      stdout: error.stdout || '',
+      stderr: error.stderr || error.message,
+      exitCode: error.code || 1,
+    };
+  }
+}
+
+async function processList(): Promise<any> {
+  try {
+    const isWindows = process.platform === 'win32';
+    const cmd = isWindows ? 'tasklist' : 'ps aux';
+    const { stdout } = await exec(cmd);
+
+    return { success: true, processes: stdout };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function systemInfo(): Promise<any> {
+  const os = await import('os');
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    nodeVersion: process.version,
+    uptime: os.uptime(),
+    cpus: os.cpus().length,
+    totalMemory: os.totalmem(),
+    freeMemory: os.freemem(),
+    hostname: os.hostname(),
+    userInfo: os.userInfo(),
+  };
+}
+
+export function registerTerminalTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('shell_exec', {
+    description: 'Execute shell command',
+    inputSchema: ShellExecSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await shellExec(params), null, 2) }],
+  }));
+
+  server.tool('process_list', 'List running processes', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await processList(), null, 2) }],
+  }));
+
+  server.tool('system_info', 'Get system information', {}, async () => ({
+    content: [{ type: 'text', text: JSON.stringify(await systemInfo(), null, 2) }],
+  }));
+
+  registry.register({ name: 'shell_exec', category: 'terminal', description: 'Execute shell command', handler: shellExec });
+  registry.register({ name: 'process_list', category: 'terminal', description: 'List processes', handler: processList });
+  registry.register({ name: 'system_info', category: 'terminal', description: 'System info', handler: systemInfo });
+
+  log.info('Registered 3 terminal tools');
+}

package/src/tools/web/index.ts

@@ -0,0 +1,224 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v3';
+import axios from 'axios';
+import * as cheerio from 'cheerio';
+import { ToolRegistry } from '../../core/registry.js';
+import { createContextLogger } from '../../core/logger.js';
+import { nexusConfig } from '../../core/config.js';
+
+const log = createContextLogger('tools/web');
+
+const WebSearchSchema = z.object({
+  query: z.string().describe('Search query'),
+  maxResults: z.number().optional().default(10).describe('Maximum number of results'),
+});
+
+const WebBrowseSchema = z.object({
+  url: z.string().describe('URL to browse'),
+  actions: z.string().optional().describe('JavaScript code to execute on the page'),
+  waitFor: z.number().optional().default(2000).describe('Time to wait after page load (ms)'),
+});
+
+const WebScrapeSchema = z.object({
+  url: z.string().describe('URL to scrape'),
+  selector: z.string().optional().describe('CSS selector to extract specific content'),
+});
+
+const ApiCallSchema = z.object({
+  method: z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']).describe('HTTP method'),
+  url: z.string().describe('API endpoint URL'),
+  headers: z.record(z.string()).optional().describe('HTTP headers'),
+  body: z.any().optional().describe('Request body'),
+});
+
+type WebSearchParams = z.infer<typeof WebSearchSchema>;
+type WebBrowseParams = z.infer<typeof WebBrowseSchema>;
+type WebScrapeParams = z.infer<typeof WebScrapeSchema>;
+type ApiCallParams = z.infer<typeof ApiCallSchema>;
+
+async function webSearch(params: WebSearchParams): Promise<any> {
+  const { query, maxResults = 10 } = params;
+  log.info(`Web search: "${query}"`);
+
+  if (nexusConfig.search.braveApiKey) {
+    try {
+      const response = await axios.get('https://api.search.brave.com/res/v1/web/search', {
+        params: { q: query, count: maxResults },
+        headers: { 'X-Subscription-Token': nexusConfig.search.braveApiKey },
+        timeout: 15000,
+      });
+      return {
+        success: true,
+        provider: 'brave',
+        results: response.data.web?.results?.map((r: any) => ({
+          title: r.title,
+          url: r.url,
+          snippet: r.description,
+        })) || [],
+      };
+    } catch (error) {
+      log.warn('Brave search failed, falling back to DuckDuckGo');
+    }
+  }
+
+  try {
+    const response = await axios.get('https://html.duckduckgo.com/html/', {
+      params: { q: query },
+      headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' },
+      timeout: 15000,
+    });
+
+    const $ = cheerio.load(response.data);
+    const results: any[] = [];
+    $('.result').slice(0, maxResults).each((_, el) => {
+      const title = $(el).find('.result__title a').text().trim();
+      const url = $(el).find('.result__url').text().trim();
+      const snippet = $(el).find('.result__snippet').text().trim();
+      if (title && url) {
+        results.push({ title, url: url.startsWith('http') ? url : `https://${url}`, snippet });
+      }
+    });
+
+    return { success: true, provider: 'duckduckgo', results };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function webBrowse(params: WebBrowseParams): Promise<any> {
+  const { url, actions, waitFor = 2000 } = params;
+  log.info(`Browsing: ${url}`);
+
+  try {
+    const { chromium } = await import('playwright');
+    const browser = await chromium.launch({ headless: nexusConfig.browser.headless });
+    const page = await browser.newPage();
+
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: nexusConfig.browser.timeout });
+
+    if (waitFor > 0) await page.waitForTimeout(waitFor);
+
+    if (actions) {
+      try {
+        const actionFn = new Function('page', actions);
+        await actionFn(page);
+      } catch (err: any) {
+        log.warn(`Action execution failed: ${err.message}`);
+      }
+    }
+
+    const title = await page.title();
+    const content = await page.content();
+    const text = await page.evaluate(`document.body?.innerText || ''`) as string;
+    const snapshot = await (page as any).accessibility.snapshot();
+
+    await browser.close();
+
+    return {
+      success: true,
+      url,
+      title,
+      text: text.slice(0, 50000),
+      accessibilityTree: snapshot,
+    };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function webScrape(params: WebScrapeParams): Promise<any> {
+  const { url, selector } = params;
+  log.info(`Scraping: ${url}`);
+
+  try {
+    const response = await axios.get(url, {
+      headers: { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' },
+      timeout: 15000,
+    });
+
+    const $ = cheerio.load(response.data);
+    $('script, style, nav, footer, header').remove();
+
+    let content = '';
+    if (selector) {
+      content = $(selector).text();
+    } else {
+      content = $('body').text();
+    }
+
+    content = content.replace(/\s+/g, ' ').trim();
+
+    return {
+      success: true,
+      url,
+      content: content.slice(0, 100000),
+    };
+  } catch (error: any) {
+    return { success: false, error: error.message };
+  }
+}
+
+async function apiCall(params: ApiCallParams): Promise<any> {
+  const { method, url, headers, body } = params;
+  log.info(`API call: ${method} ${url}`);
+
+  try {
+    const response = await axios({
+      method: method as any,
+      url,
+      headers,
+      data: body,
+      timeout: 30000,
+    });
+
+    return {
+      success: true,
+      status: response.status,
+      headers: response.headers,
+      data: response.data,
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      status: error.response?.status,
+      error: error.message,
+    };
+  }
+}
+
+export function registerWebTools(server: McpServer, registry: ToolRegistry): void {
+  server.registerTool('web_search', {
+    description: 'Search the web for information',
+    inputSchema: WebSearchSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await webSearch(params), null, 2) }],
+  }));
+
+  server.registerTool('web_browse', {
+    description: 'Browse a webpage with Playwright and extract content',
+    inputSchema: WebBrowseSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await webBrowse(params), null, 2) }],
+  }));
+
+  server.registerTool('web_scrape', {
+    description: 'Scrape content from a webpage',
+    inputSchema: WebScrapeSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await webScrape(params), null, 2) }],
+  }));
+
+  server.registerTool('api_call', {
+    description: 'Make HTTP API calls (REST/GraphQL)',
+    inputSchema: ApiCallSchema,
+  }, async (params) => ({
+    content: [{ type: 'text', text: JSON.stringify(await apiCall(params), null, 2) }],
+  }));
+
+  registry.register({ name: 'web_search', category: 'web', description: 'Search the web', handler: webSearch });
+  registry.register({ name: 'web_browse', category: 'web', description: 'Browse webpage', handler: webBrowse });
+  registry.register({ name: 'web_scrape', category: 'web', description: 'Scrape webpage', handler: webScrape });
+  registry.register({ name: 'api_call', category: 'web', description: 'HTTP API call', handler: apiCall });
+
+  log.info('Registered 4 web tools');
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "allowSyntheticDefaultImports": true,
+    "isolatedModules": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}