opc-agent 4.1.2 → 4.1.4

package/src/tools/builtin/browser.ts

@@ -1,299 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
-const MAX_TEXT_LENGTH = 5000;
-
-export class BrowserManager {
-  private browser: any = null;
-  private page: any = null;
-  private lastActivity: number = 0;
-  private idleTimer: ReturnType<typeof setTimeout> | null = null;
-  private playwrightFactory: (() => any) | null;
-
-  constructor(playwrightFactory?: () => any) {
-    this.playwrightFactory = playwrightFactory || null;
-  }
-
-  private resetIdleTimer(): void {
-    this.lastActivity = Date.now();
-    if (this.idleTimer) clearTimeout(this.idleTimer);
-    this.idleTimer = setTimeout(() => this.close(), IDLE_TIMEOUT_MS);
-  }
-
-  async ensureBrowser(): Promise<any> {
-    if (!this.browser) {
-      let playwright: any;
-      if (this.playwrightFactory) {
-        playwright = this.playwrightFactory();
-      } else {
-        try {
-          playwright = require('playwright');
-        } catch {
-          throw new Error('Install playwright: npm i playwright');
-        }
-      }
-      this.browser = await playwright.chromium.launch({ headless: true });
-      const context = await this.browser.newContext();
-      this.page = await context.newPage();
-    }
-    this.resetIdleTimer();
-    return this.page;
-  }
-
-  async navigate(url: string): Promise<{ title: string; text: string; url: string }> {
-    const page = await this.ensureBrowser();
-    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-    const title = await page.title();
-    const text = (await page.innerText('body')).slice(0, MAX_TEXT_LENGTH);
-    return { title, text, url: page.url() };
-  }
-
-  async click(selector: string): Promise<void> {
-    const page = await this.ensureBrowser();
-    await page.click(selector, { timeout: 10000 });
-  }
-
-  async type(selector: string, text: string): Promise<void> {
-    const page = await this.ensureBrowser();
-    await page.fill(selector, text, { timeout: 10000 });
-  }
-
-  async screenshot(): Promise<string> {
-    const page = await this.ensureBrowser();
-    const buffer = await page.screenshot({ type: 'png' });
-    return buffer.toString('base64');
-  }
-
-  async extract(): Promise<{ text: string; links: string[]; images: string[] }> {
-    const page = await this.ensureBrowser();
-    const text = (await page.innerText('body')).slice(0, MAX_TEXT_LENGTH);
-    const links: string[] = await page.$$eval('a[href]', (els: any[]) => els.map((e: any) => e.href).slice(0, 100));
-    const images: string[] = await page.$$eval('img[src]', (els: any[]) => els.map((e: any) => e.src).slice(0, 100));
-    return { text, links, images };
-  }
-
-  async scroll(direction: 'up' | 'down', amount?: number): Promise<void> {
-    const page = await this.ensureBrowser();
-    const delta = amount || 500;
-    const scrollScript = direction === 'down'
-      ? `window.scrollBy(0, ${delta})`
-      : `window.scrollBy(0, -${delta})`;
-    await page.evaluate(scrollScript);
-  }
-
-  async back(): Promise<void> {
-    const page = await this.ensureBrowser();
-    await page.goBack({ timeout: 10000 });
-  }
-
-  async evaluate(script: string): Promise<any> {
-    const page = await this.ensureBrowser();
-    return await page.evaluate(script);
-  }
-
-  async getImages(): Promise<Array<{ src: string; alt: string }>> {
-    const page = await this.ensureBrowser();
-    return await page.$$eval('img', (els: any[]) =>
-      els.map((e: any) => ({ src: e.src, alt: e.alt || '' })).slice(0, 200)
-    );
-  }
-
-  async waitFor(selector: string, timeout?: number): Promise<boolean> {
-    const page = await this.ensureBrowser();
-    try {
-      await page.waitForSelector(selector, { timeout: timeout || 5000 });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async close(): Promise<void> {
-    if (this.idleTimer) {
-      clearTimeout(this.idleTimer);
-      this.idleTimer = null;
-    }
-    if (this.browser) {
-      try { await this.browser.close(); } catch {}
-      this.browser = null;
-      this.page = null;
-    }
-  }
-}
-
-// Singleton
-const browserManager = new BrowserManager();
-
-function wrapTool(fn: () => Promise<MCPToolResult>): Promise<MCPToolResult> {
-  return fn().catch((err: any) => ({
-    content: `Browser error: ${err instanceof Error ? err.message : String(err)}`,
-    isError: true,
-  }));
-}
-
-export const browserNavigateTool: MCPTool = {
-  name: 'browser_navigate',
-  description: 'Navigate to a URL and return page title + text content (truncated)',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      url: { type: 'string', description: 'URL to navigate to' },
-    },
-    required: ['url'],
-  },
-  execute: (input) => wrapTool(async () => {
-    const url = input.url as string;
-    if (!url) return { content: 'Missing required parameter: url', isError: true };
-    const result = await browserManager.navigate(url);
-    return { content: `Title: ${result.title}\nURL: ${result.url}\n\n${result.text}`, isError: false };
-  }),
-};
-
-export const browserClickTool: MCPTool = {
-  name: 'browser_click',
-  description: 'Click an element by CSS selector',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      selector: { type: 'string', description: 'CSS selector of element to click' },
-    },
-    required: ['selector'],
-  },
-  execute: (input) => wrapTool(async () => {
-    const selector = input.selector as string;
-    if (!selector) return { content: 'Missing required parameter: selector', isError: true };
-    await browserManager.click(selector);
-    return { content: `Clicked: ${selector}`, isError: false };
-  }),
-};
-
-export const browserTypeTool: MCPTool = {
-  name: 'browser_type',
-  description: 'Type text into an element by CSS selector',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      selector: { type: 'string', description: 'CSS selector of input element' },
-      text: { type: 'string', description: 'Text to type' },
-    },
-    required: ['selector', 'text'],
-  },
-  execute: (input) => wrapTool(async () => {
-    const selector = input.selector as string;
-    const text = input.text as string;
-    if (!selector || text === undefined) return { content: 'Missing required parameters: selector, text', isError: true };
-    await browserManager.type(selector, text);
-    return { content: `Typed into ${selector}`, isError: false };
-  }),
-};
-
-export const browserScreenshotTool: MCPTool = {
-  name: 'browser_screenshot',
-  description: 'Take a screenshot of the current page, returned as base64 PNG',
-  inputSchema: { type: 'object', properties: {} },
-  execute: () => wrapTool(async () => {
-    const base64 = await browserManager.screenshot();
-    return { content: base64, isError: false, metadata: { encoding: 'base64', mimeType: 'image/png' } };
-  }),
-};
-
-export const browserExtractTool: MCPTool = {
-  name: 'browser_extract',
-  description: 'Extract text, links, and images from the current page',
-  inputSchema: { type: 'object', properties: {} },
-  execute: () => wrapTool(async () => {
-    const data = await browserManager.extract();
-    return { content: JSON.stringify(data, null, 2), isError: false };
-  }),
-};
-
-export const browserScrollTool: MCPTool = {
-  name: 'browser_scroll',
-  description: 'Scroll the page up or down',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      direction: { type: 'string', enum: ['up', 'down'], description: 'Scroll direction' },
-      amount: { type: 'number', description: 'Pixels to scroll (default 500)' },
-    },
-    required: ['direction'],
-  },
-  execute: (input) => wrapTool(async () => {
-    const direction = input.direction as 'up' | 'down';
-    if (!direction) return { content: 'Missing required parameter: direction', isError: true };
-    await browserManager.scroll(direction, input.amount as number | undefined);
-    return { content: `Scrolled ${direction}`, isError: false };
-  }),
-};
-
-export const browserBackTool: MCPTool = {
-  name: 'browser_back',
-  description: 'Navigate back in browser history',
-  inputSchema: { type: 'object', properties: {} },
-  execute: () => wrapTool(async () => {
-    await browserManager.back();
-    return { content: 'Navigated back', isError: false };
-  }),
-};
-
-export const browserEvalTool: MCPTool = {
-  name: 'browser_eval',
-  description: 'Execute JavaScript in the page context',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      script: { type: 'string', description: 'JavaScript to execute' },
-    },
-    required: ['script'],
-  },
-  execute: (input) => wrapTool(async () => {
-    const script = input.script as string;
-    if (!script) return { content: 'Missing required parameter: script', isError: true };
-    const result = await browserManager.evaluate(script);
-    return { content: typeof result === 'string' ? result : JSON.stringify(result, null, 2), isError: false };
-  }),
-};
-
-export const browserGetImagesTool: MCPTool = {
-  name: 'browser_get_images',
-  description: 'List all images on the current page with src and alt attributes',
-  inputSchema: { type: 'object', properties: {} },
-  execute: () => wrapTool(async () => {
-    const images = await browserManager.getImages();
-    return { content: JSON.stringify(images, null, 2), isError: false };
-  }),
-};
-
-export const browserWaitTool: MCPTool = {
-  name: 'browser_wait',
-  description: 'Wait for a CSS selector to appear on the page',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      selector: { type: 'string', description: 'CSS selector to wait for' },
-      timeout: { type: 'number', description: 'Max wait time in ms (default 5000)' },
-    },
-    required: ['selector'],
-  },
-  execute: (input) => wrapTool(async () => {
-    const selector = input.selector as string;
-    if (!selector) return { content: 'Missing required parameter: selector', isError: true };
-    const found = await browserManager.waitFor(selector, input.timeout as number | undefined);
-    return { content: found ? `Found: ${selector}` : `Timeout waiting for: ${selector}`, isError: !found };
-  }),
-};
-
-export const browserTools: MCPTool[] = [
-  browserNavigateTool,
-  browserClickTool,
-  browserTypeTool,
-  browserScreenshotTool,
-  browserExtractTool,
-  browserScrollTool,
-  browserBackTool,
-  browserEvalTool,
-  browserGetImagesTool,
-  browserWaitTool,
-];
-
-export { browserManager };

package/src/tools/builtin/datetime.ts

@@ -1,41 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const datetimeTool: MCPTool = {
-  name: 'datetime',
-  description: 'Get current date, time, timezone info',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      format: { type: 'string', default: 'iso' },
-      timezone: { type: 'string' },
-    },
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const now = new Date();
-    const timezone = input.timezone as string | undefined;
-    const format = (input.format as string) || 'iso';
-
-    let content: string;
-    if (format === 'iso') {
-      content = now.toISOString();
-    } else if (format === 'locale') {
-      content = timezone
-        ? now.toLocaleString('en-US', { timeZone: timezone })
-        : now.toLocaleString();
-    } else if (format === 'unix') {
-      content = String(Math.floor(now.getTime() / 1000));
-    } else {
-      content = now.toISOString();
-    }
-
-    return {
-      content: JSON.stringify({
-        iso: now.toISOString(),
-        unix: Math.floor(now.getTime() / 1000),
-        formatted: content,
-        timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
-      }),
-      isError: false,
-    };
-  },
-};

package/src/tools/builtin/file.ts

@@ -1,107 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { MCPTool, MCPToolResult } from '../mcp';
-import type { AgentContext } from '../../core/types';
-
-function resolveSafe(basePath: string, targetPath: string): string | null {
-  const resolved = path.resolve(basePath, targetPath);
-  if (!resolved.startsWith(path.resolve(basePath))) return null;
-  return resolved;
-}
-
-function searchFiles(dir: string, query: string, results: string[] = [], maxResults = 20): string[] {
-  if (results.length >= maxResults) return results;
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (results.length >= maxResults) break;
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === 'node_modules' || entry.name === '.git') continue;
-        searchFiles(full, query, results, maxResults);
-      } else if (entry.isFile()) {
-        try {
-          const content = fs.readFileSync(full, 'utf-8');
-          const lines = content.split('\n');
-          for (let i = 0; i < lines.length; i++) {
-            if (lines[i].includes(query)) {
-              results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
-              if (results.length >= maxResults) break;
-            }
-          }
-        } catch { /* skip binary/unreadable */ }
-      }
-    }
-  } catch { /* skip inaccessible dirs */ }
-  return results;
-}
-
-export const fileTool: MCPTool = {
-  name: 'file_operations',
-  description: 'Read, write, list, and search files in the workspace',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['read', 'write', 'list', 'search', 'exists'] },
-      path: { type: 'string' },
-      content: { type: 'string' },
-      query: { type: 'string' },
-    },
-    required: ['action'],
-  },
-  async execute(input: Record<string, unknown>, context?: AgentContext): Promise<MCPToolResult> {
-    const action = input.action as string;
-    const workspace = process.cwd();
-    const targetPath = input.path as string | undefined;
-
-    if (action === 'search') {
-      const query = input.query as string;
-      if (!query) return { content: 'query is required for search', isError: true };
-      const results = searchFiles(workspace, query);
-      return { content: results.length ? results.join('\n') : 'No matches found', isError: false };
-    }
-
-    if (action === 'list') {
-      const dir = targetPath ? resolveSafe(workspace, targetPath) : workspace;
-      if (!dir) return { content: 'Path outside workspace', isError: true };
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        const listing = entries.map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`).join('\n');
-        return { content: listing || '(empty directory)', isError: false };
-      } catch (err) {
-        return { content: `Error listing directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
-      }
-    }
-
-    if (!targetPath) return { content: 'path is required', isError: true };
-    const resolved = resolveSafe(workspace, targetPath);
-    if (!resolved) return { content: 'Path outside workspace', isError: true };
-
-    switch (action) {
-      case 'read': {
-        try {
-          const content = fs.readFileSync(resolved, 'utf-8');
-          return { content: content.slice(0, 50000), isError: false };
-        } catch (err) {
-          return { content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
-        }
-      }
-      case 'write': {
-        const content = input.content as string;
-        if (content === undefined) return { content: 'content is required for write', isError: true };
-        try {
-          fs.mkdirSync(path.dirname(resolved), { recursive: true });
-          fs.writeFileSync(resolved, content, 'utf-8');
-          return { content: `Written ${content.length} bytes to ${targetPath}`, isError: false };
-        } catch (err) {
-          return { content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
-        }
-      }
-      case 'exists': {
-        return { content: String(fs.existsSync(resolved)), isError: false };
-      }
-      default:
-        return { content: `Unknown action: ${action}`, isError: true };
-    }
-  },
-};

package/src/tools/builtin/home-assistant.ts

@@ -1,116 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export interface HomeAssistantConfig {
-  url: string;
-  token: string;
-}
-
-let haConfig: HomeAssistantConfig | null = null;
-
-export function configureHomeAssistant(config: HomeAssistantConfig): void {
-  haConfig = config;
-}
-
-async function haFetch(path: string, options?: RequestInit): Promise<any> {
-  if (!haConfig) throw new Error('Home Assistant not configured. Call configureHomeAssistant({ url, token }) first.');
-  const resp = await fetch(`${haConfig.url}/api${path}`, {
-    ...options,
-    headers: { Authorization: `Bearer ${haConfig.token}`, 'Content-Type': 'application/json', ...options?.headers as Record<string, string> },
-  });
-  if (!resp.ok) throw new Error(`HA API error: ${resp.status} ${resp.statusText}`);
-  return resp.json();
-}
-
-export const haGetStates: MCPTool = {
-  name: 'ha_get_states',
-  description: 'Get all Home Assistant entity states or filter by domain',
-  inputSchema: {
-    type: 'object',
-    properties: { domain: { type: 'string', description: 'Filter by domain (e.g. light, switch)' } },
-  },
-  async execute(input): Promise<MCPToolResult> {
-    try {
-      let states = await haFetch('/states');
-      if (input.domain) states = states.filter((s: any) => s.entity_id.startsWith(`${input.domain}.`));
-      return { content: JSON.stringify(states.map((s: any) => ({ entity_id: s.entity_id, state: s.state, attributes: s.attributes }))) };
-    } catch (e: any) { return { content: e.message, isError: true }; }
-  },
-};
-
-export const haCallService: MCPTool = {
-  name: 'ha_call_service',
-  description: 'Call a Home Assistant service (turn_on, turn_off, toggle, etc.)',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      domain: { type: 'string' },
-      service: { type: 'string' },
-      entity_id: { type: 'string' },
-      data: { type: 'object' },
-    },
-    required: ['domain', 'service'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    try {
-      const body: any = {};
-      if (input.entity_id) body.entity_id = input.entity_id;
-      if (input.data) Object.assign(body, input.data);
-      const result = await haFetch(`/services/${input.domain}/${input.service}`, {
-        method: 'POST', body: JSON.stringify(body),
-      });
-      return { content: JSON.stringify({ success: true, result }) };
-    } catch (e: any) { return { content: e.message, isError: true }; }
-  },
-};
-
-export const haGetHistory: MCPTool = {
-  name: 'ha_get_history',
-  description: 'Get entity history for a time period',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      entity_id: { type: 'string' },
-      start: { type: 'string', description: 'ISO datetime' },
-      end: { type: 'string', description: 'ISO datetime' },
-    },
-    required: ['entity_id'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    try {
-      const start = input.start || new Date(Date.now() - 86400000).toISOString();
-      let path = `/history/period/${start}?filter_entity_id=${input.entity_id}`;
-      if (input.end) path += `&end_time=${input.end}`;
-      const result = await haFetch(path);
-      return { content: JSON.stringify(result) };
-    } catch (e: any) { return { content: e.message, isError: true }; }
-  },
-};
-
-export const haAutomation: MCPTool = {
-  name: 'ha_automation',
-  description: 'Trigger or manage Home Assistant automations',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['trigger', 'turn_on', 'turn_off', 'list'] },
-      automation_id: { type: 'string' },
-    },
-    required: ['action'],
-  },
-  async execute(input): Promise<MCPToolResult> {
-    try {
-      if (input.action === 'list') {
-        const states = await haFetch('/states');
-        const automations = states.filter((s: any) => s.entity_id.startsWith('automation.'));
-        return { content: JSON.stringify(automations.map((a: any) => ({ entity_id: a.entity_id, state: a.state }))) };
-      }
-      if (!input.automation_id) return { content: 'automation_id required for this action', isError: true };
-      const result = await haFetch(`/services/automation/${input.action}`, {
-        method: 'POST', body: JSON.stringify({ entity_id: input.automation_id }),
-      });
-      return { content: JSON.stringify({ success: true, result }) };
-    } catch (e: any) { return { content: e.message, isError: true }; }
-  },
-};
-
-export const homeAssistantTools: MCPTool[] = [haGetStates, haCallService, haGetHistory, haAutomation];

package/src/tools/builtin/index.ts

@@ -1,37 +0,0 @@
-import type { MCPTool } from '../mcp';
-import { fileTool } from './file';
-import { webTool } from './web';
-import { shellTool } from './shell';
-import { datetimeTool } from './datetime';
-import { browserTools, BrowserManager, browserManager } from './browser';
-import { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool } from './vision';
-import { rlTools } from './rl-tools';
-import { homeAssistantTools } from './home-assistant';
-import { webSearchTools, webSearchTool, webReadTool } from './web-search';
-
-export { fileTool, webTool, shellTool, datetimeTool, browserTools, BrowserManager, browserManager };
-export { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool };
-export { rlTools } from './rl-tools';
-export { homeAssistantTools, configureHomeAssistant } from './home-assistant';
-export { webSearchTools, webSearchTool, webReadTool } from './web-search';
-
-const ALL_BUILTIN_TOOLS: MCPTool[] = [fileTool, webTool, shellTool, datetimeTool, ...browserTools, ...visionTools, ...rlTools, ...homeAssistantTools, ...webSearchTools];
-
-const BUILTIN_MAP = new Map<string, MCPTool>(
-  ALL_BUILTIN_TOOLS.map(t => [t.name, t])
-);
-
-/**
- * Get all built-in tools.
- */
-export function getBuiltinTools(): MCPTool[] {
-  return [...ALL_BUILTIN_TOOLS];
-}
-
-/**
- * Get specific built-in tools by name. If no names given, returns all.
- */
-export function getBuiltinToolsByName(names?: string[]): MCPTool[] {
-  if (!names || names.length === 0) return getBuiltinTools();
-  return names.map(n => BUILTIN_MAP.get(n)).filter((t): t is MCPTool => !!t);
-}