opc-agent 3.0.1 → 4.0.0

package/dist/tools/builtin/browser.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserManager = exports.browserTools = exports.browserWaitTool = exports.browserGetImagesTool = exports.browserEvalTool = exports.browserBackTool = exports.browserScrollTool = exports.browserExtractTool = exports.browserScreenshotTool = exports.browserTypeTool = exports.browserClickTool = exports.browserNavigateTool = exports.BrowserManager = void 0;
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const MAX_TEXT_LENGTH = 5000;
+class BrowserManager {
+    browser = null;
+    page = null;
+    lastActivity = 0;
+    idleTimer = null;
+    playwrightFactory;
+    constructor(playwrightFactory) {
+        this.playwrightFactory = playwrightFactory || null;
+    }
+    resetIdleTimer() {
+        this.lastActivity = Date.now();
+        if (this.idleTimer)
+            clearTimeout(this.idleTimer);
+        this.idleTimer = setTimeout(() => this.close(), IDLE_TIMEOUT_MS);
+    }
+    async ensureBrowser() {
+        if (!this.browser) {
+            let playwright;
+            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) {
+        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) {
+        const page = await this.ensureBrowser();
+        await page.click(selector, { timeout: 10000 });
+    }
+    async type(selector, text) {
+        const page = await this.ensureBrowser();
+        await page.fill(selector, text, { timeout: 10000 });
+    }
+    async screenshot() {
+        const page = await this.ensureBrowser();
+        const buffer = await page.screenshot({ type: 'png' });
+        return buffer.toString('base64');
+    }
+    async extract() {
+        const page = await this.ensureBrowser();
+        const text = (await page.innerText('body')).slice(0, MAX_TEXT_LENGTH);
+        const links = await page.$$eval('a[href]', (els) => els.map((e) => e.href).slice(0, 100));
+        const images = await page.$$eval('img[src]', (els) => els.map((e) => e.src).slice(0, 100));
+        return { text, links, images };
+    }
+    async scroll(direction, amount) {
+        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() {
+        const page = await this.ensureBrowser();
+        await page.goBack({ timeout: 10000 });
+    }
+    async evaluate(script) {
+        const page = await this.ensureBrowser();
+        return await page.evaluate(script);
+    }
+    async getImages() {
+        const page = await this.ensureBrowser();
+        return await page.$$eval('img', (els) => els.map((e) => ({ src: e.src, alt: e.alt || '' })).slice(0, 200));
+    }
+    async waitFor(selector, timeout) {
+        const page = await this.ensureBrowser();
+        try {
+            await page.waitForSelector(selector, { timeout: timeout || 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async close() {
+        if (this.idleTimer) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+        if (this.browser) {
+            try {
+                await this.browser.close();
+            }
+            catch { }
+            this.browser = null;
+            this.page = null;
+        }
+    }
+}
+exports.BrowserManager = BrowserManager;
+// Singleton
+const browserManager = new BrowserManager();
+exports.browserManager = browserManager;
+function wrapTool(fn) {
+    return fn().catch((err) => ({
+        content: `Browser error: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true,
+    }));
+}
+exports.browserNavigateTool = {
+    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;
+        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 };
+    }),
+};
+exports.browserClickTool = {
+    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;
+        if (!selector)
+            return { content: 'Missing required parameter: selector', isError: true };
+        await browserManager.click(selector);
+        return { content: `Clicked: ${selector}`, isError: false };
+    }),
+};
+exports.browserTypeTool = {
+    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;
+        const text = input.text;
+        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 };
+    }),
+};
+exports.browserScreenshotTool = {
+    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' } };
+    }),
+};
+exports.browserExtractTool = {
+    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 };
+    }),
+};
+exports.browserScrollTool = {
+    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;
+        if (!direction)
+            return { content: 'Missing required parameter: direction', isError: true };
+        await browserManager.scroll(direction, input.amount);
+        return { content: `Scrolled ${direction}`, isError: false };
+    }),
+};
+exports.browserBackTool = {
+    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 };
+    }),
+};
+exports.browserEvalTool = {
+    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;
+        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 };
+    }),
+};
+exports.browserGetImagesTool = {
+    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 };
+    }),
+};
+exports.browserWaitTool = {
+    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;
+        if (!selector)
+            return { content: 'Missing required parameter: selector', isError: true };
+        const found = await browserManager.waitFor(selector, input.timeout);
+        return { content: found ? `Found: ${selector}` : `Timeout waiting for: ${selector}`, isError: !found };
+    }),
+};
+exports.browserTools = [
+    exports.browserNavigateTool,
+    exports.browserClickTool,
+    exports.browserTypeTool,
+    exports.browserScreenshotTool,
+    exports.browserExtractTool,
+    exports.browserScrollTool,
+    exports.browserBackTool,
+    exports.browserEvalTool,
+    exports.browserGetImagesTool,
+    exports.browserWaitTool,
+];
+//# sourceMappingURL=browser.js.map

package/dist/tools/builtin/home-assistant.d.ts

@@ -0,0 +1,12 @@
+import type { MCPTool } from '../mcp';
+export interface HomeAssistantConfig {
+    url: string;
+    token: string;
+}
+export declare function configureHomeAssistant(config: HomeAssistantConfig): void;
+export declare const haGetStates: MCPTool;
+export declare const haCallService: MCPTool;
+export declare const haGetHistory: MCPTool;
+export declare const haAutomation: MCPTool;
+export declare const homeAssistantTools: MCPTool[];
+//# sourceMappingURL=home-assistant.d.ts.map

package/dist/tools/builtin/home-assistant.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.homeAssistantTools = exports.haAutomation = exports.haGetHistory = exports.haCallService = exports.haGetStates = void 0;
+exports.configureHomeAssistant = configureHomeAssistant;
+let haConfig = null;
+function configureHomeAssistant(config) {
+    haConfig = config;
+}
+async function haFetch(path, options) {
+    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 },
+    });
+    if (!resp.ok)
+        throw new Error(`HA API error: ${resp.status} ${resp.statusText}`);
+    return resp.json();
+}
+exports.haGetStates = {
+    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) {
+        try {
+            let states = await haFetch('/states');
+            if (input.domain)
+                states = states.filter((s) => s.entity_id.startsWith(`${input.domain}.`));
+            return { content: JSON.stringify(states.map((s) => ({ entity_id: s.entity_id, state: s.state, attributes: s.attributes }))) };
+        }
+        catch (e) {
+            return { content: e.message, isError: true };
+        }
+    },
+};
+exports.haCallService = {
+    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) {
+        try {
+            const body = {};
+            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) {
+            return { content: e.message, isError: true };
+        }
+    },
+};
+exports.haGetHistory = {
+    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) {
+        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) {
+            return { content: e.message, isError: true };
+        }
+    },
+};
+exports.haAutomation = {
+    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) {
+        try {
+            if (input.action === 'list') {
+                const states = await haFetch('/states');
+                const automations = states.filter((s) => s.entity_id.startsWith('automation.'));
+                return { content: JSON.stringify(automations.map((a) => ({ 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) {
+            return { content: e.message, isError: true };
+        }
+    },
+};
+exports.homeAssistantTools = [exports.haGetStates, exports.haCallService, exports.haGetHistory, exports.haAutomation];
+//# sourceMappingURL=home-assistant.js.map

package/dist/tools/builtin/index.d.ts

@@ -3,7 +3,12 @@ import { fileTool } from './file';
 import { webTool } from './web';
 import { shellTool } from './shell';
 import { datetimeTool } from './datetime';
-export { fileTool, webTool, shellTool, datetimeTool };
+import { browserTools, BrowserManager, browserManager } from './browser';
+import { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool } from './vision';
+export { fileTool, webTool, shellTool, datetimeTool, browserTools, BrowserManager, browserManager };
+export { visionTools, visionAnalyzeTool, visionExtractTextTool, visionCompareTool };
+export { rlTools } from './rl-tools';
+export { homeAssistantTools, configureHomeAssistant } from './home-assistant';
 /**
  * Get all built-in tools.
  */

package/dist/tools/builtin/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.datetimeTool = exports.shellTool = exports.webTool = exports.fileTool = void 0;
+exports.configureHomeAssistant = exports.homeAssistantTools = exports.rlTools = exports.visionCompareTool = exports.visionExtractTextTool = exports.visionAnalyzeTool = exports.visionTools = exports.browserManager = exports.BrowserManager = exports.browserTools = exports.datetimeTool = exports.shellTool = exports.webTool = exports.fileTool = void 0;
 exports.getBuiltinTools = getBuiltinTools;
 exports.getBuiltinToolsByName = getBuiltinToolsByName;
 const file_1 = require("./file");
@@ -11,7 +11,23 @@ const shell_1 = require("./shell");
 Object.defineProperty(exports, "shellTool", { enumerable: true, get: function () { return shell_1.shellTool; } });
 const datetime_1 = require("./datetime");
 Object.defineProperty(exports, "datetimeTool", { enumerable: true, get: function () { return datetime_1.datetimeTool; } });
-const ALL_BUILTIN_TOOLS = [file_1.fileTool, web_1.webTool, shell_1.shellTool, datetime_1.datetimeTool];
+const browser_1 = require("./browser");
+Object.defineProperty(exports, "browserTools", { enumerable: true, get: function () { return browser_1.browserTools; } });
+Object.defineProperty(exports, "BrowserManager", { enumerable: true, get: function () { return browser_1.BrowserManager; } });
+Object.defineProperty(exports, "browserManager", { enumerable: true, get: function () { return browser_1.browserManager; } });
+const vision_1 = require("./vision");
+Object.defineProperty(exports, "visionTools", { enumerable: true, get: function () { return vision_1.visionTools; } });
+Object.defineProperty(exports, "visionAnalyzeTool", { enumerable: true, get: function () { return vision_1.visionAnalyzeTool; } });
+Object.defineProperty(exports, "visionExtractTextTool", { enumerable: true, get: function () { return vision_1.visionExtractTextTool; } });
+Object.defineProperty(exports, "visionCompareTool", { enumerable: true, get: function () { return vision_1.visionCompareTool; } });
+const rl_tools_1 = require("./rl-tools");
+const home_assistant_1 = require("./home-assistant");
+var rl_tools_2 = require("./rl-tools");
+Object.defineProperty(exports, "rlTools", { enumerable: true, get: function () { return rl_tools_2.rlTools; } });
+var home_assistant_2 = require("./home-assistant");
+Object.defineProperty(exports, "homeAssistantTools", { enumerable: true, get: function () { return home_assistant_2.homeAssistantTools; } });
+Object.defineProperty(exports, "configureHomeAssistant", { enumerable: true, get: function () { return home_assistant_2.configureHomeAssistant; } });
+const ALL_BUILTIN_TOOLS = [file_1.fileTool, web_1.webTool, shell_1.shellTool, datetime_1.datetimeTool, ...browser_1.browserTools, ...vision_1.visionTools, ...rl_tools_1.rlTools, ...home_assistant_1.homeAssistantTools];
 const BUILTIN_MAP = new Map(ALL_BUILTIN_TOOLS.map(t => [t.name, t]));
 /**
  * Get all built-in tools.

package/dist/tools/builtin/rl-tools.d.ts

@@ -0,0 +1,13 @@
+import type { MCPTool } from '../mcp';
+export declare const rlRecordTrajectory: MCPTool;
+export declare const rlEvaluateOutcome: MCPTool;
+export declare const rlGetBestStrategy: MCPTool;
+export declare const rlCompareStrategies: MCPTool;
+export declare const rlGenerateTrainingData: MCPTool;
+export declare const rlRewardSignal: MCPTool;
+export declare const rlExplorationSuggest: MCPTool;
+export declare const rlUpdatePolicy: MCPTool;
+export declare const rlGetStatistics: MCPTool;
+export declare const rlResetEpisode: MCPTool;
+export declare const rlTools: MCPTool[];
+//# sourceMappingURL=rl-tools.d.ts.map