opc-agent 3.0.1 → 4.0.1

package/src/tools/builtin/browser.ts

@@ -0,0 +1,299 @@
+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/home-assistant.ts

@@ -0,0 +1,116 @@
+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,28 +1,37 @@
-import type { MCPTool } from '../mcp';
-import { fileTool } from './file';
-import { webTool } from './web';
-import { shellTool } from './shell';
-import { datetimeTool } from './datetime';
-
-export { fileTool, webTool, shellTool, datetimeTool };
-
-const ALL_BUILTIN_TOOLS: MCPTool[] = [fileTool, webTool, shellTool, datetimeTool];
-
-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);
-}
+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);
+}