opc-agent 2.1.0 → 3.0.0

package/dist/mcp/servers/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCryptoServer = exports.createRegexServer = exports.createJsonServer = exports.createDateTimeServer = exports.createCalculatorServer = exports.createMemoryServer = exports.createWebServer = exports.createDatabaseServer = exports.createGitHubServer = exports.createFilesystemServer = void 0;
+exports.getMCPServer = getMCPServer;
+exports.listMCPServers = listMCPServers;
+const filesystem_1 = require("./filesystem");
+Object.defineProperty(exports, "createFilesystemServer", { enumerable: true, get: function () { return filesystem_1.createFilesystemServer; } });
+const github_mcp_1 = require("./github-mcp");
+Object.defineProperty(exports, "createGitHubServer", { enumerable: true, get: function () { return github_mcp_1.createGitHubServer; } });
+const database_mcp_1 = require("./database-mcp");
+Object.defineProperty(exports, "createDatabaseServer", { enumerable: true, get: function () { return database_mcp_1.createDatabaseServer; } });
+const web_mcp_1 = require("./web-mcp");
+Object.defineProperty(exports, "createWebServer", { enumerable: true, get: function () { return web_mcp_1.createWebServer; } });
+const memory_mcp_1 = require("./memory-mcp");
+Object.defineProperty(exports, "createMemoryServer", { enumerable: true, get: function () { return memory_mcp_1.createMemoryServer; } });
+const calculator_mcp_1 = require("./calculator-mcp");
+Object.defineProperty(exports, "createCalculatorServer", { enumerable: true, get: function () { return calculator_mcp_1.createCalculatorServer; } });
+const datetime_mcp_1 = require("./datetime-mcp");
+Object.defineProperty(exports, "createDateTimeServer", { enumerable: true, get: function () { return datetime_mcp_1.createDateTimeServer; } });
+const json_mcp_1 = require("./json-mcp");
+Object.defineProperty(exports, "createJsonServer", { enumerable: true, get: function () { return json_mcp_1.createJsonServer; } });
+const regex_mcp_1 = require("./regex-mcp");
+Object.defineProperty(exports, "createRegexServer", { enumerable: true, get: function () { return regex_mcp_1.createRegexServer; } });
+const crypto_mcp_1 = require("./crypto-mcp");
+Object.defineProperty(exports, "createCryptoServer", { enumerable: true, get: function () { return crypto_mcp_1.createCryptoServer; } });
+const SERVERS = [
+    { name: 'filesystem', description: 'Read/write/list files in a sandboxed directory', factory: () => (0, filesystem_1.createFilesystemServer)() },
+    { name: 'github', description: 'GitHub API — repos, issues, files via fetch', factory: () => (0, github_mcp_1.createGitHubServer)() },
+    { name: 'database', description: 'In-memory SQL-like database with tables and queries', factory: () => (0, database_mcp_1.createDatabaseServer)() },
+    { name: 'web', description: 'Web fetch, text extraction, and search', factory: () => (0, web_mcp_1.createWebServer)() },
+    { name: 'memory', description: 'Key-value memory store with tags and search', factory: () => (0, memory_mcp_1.createMemoryServer)() },
+    { name: 'calculator', description: 'Math evaluation, unit conversion, percentages', factory: () => (0, calculator_mcp_1.createCalculatorServer)() },
+    { name: 'datetime', description: 'Time zones, date math, parsing, and formatting', factory: () => (0, datetime_mcp_1.createDateTimeServer)() },
+    { name: 'json', description: 'JSON path query, transform, validate, and diff', factory: () => (0, json_mcp_1.createJsonServer)() },
+    { name: 'regex', description: 'Regex test, match, replace, and split', factory: () => (0, regex_mcp_1.createRegexServer)() },
+    { name: 'crypto', description: 'Hash, HMAC, encrypt/decrypt, random generation', factory: () => (0, crypto_mcp_1.createCryptoServer)() },
+];
+function getMCPServer(name) {
+    const entry = SERVERS.find(s => s.name === name);
+    if (!entry)
+        throw new Error(`MCP server '${name}' not found. Available: ${SERVERS.map(s => s.name).join(', ')}`);
+    return entry.factory();
+}
+function listMCPServers() {
+    return SERVERS.map(s => {
+        const config = s.factory();
+        return { name: s.name, description: s.description, version: config.version, toolCount: config.tools?.length || 0 };
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/mcp/servers/json-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createJsonServer(): MCPServerConfig;
+//# sourceMappingURL=json-mcp.d.ts.map

package/dist/mcp/servers/json-mcp.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonServer = createJsonServer;
+function jsonPathQuery(obj, path) {
+    const parts = path.replace(/^\$\.?/, '').split('.');
+    let current = [obj];
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const next = [];
+        for (const item of current) {
+            if (part === '*') {
+                if (Array.isArray(item))
+                    next.push(...item);
+                else if (typeof item === 'object' && item)
+                    next.push(...Object.values(item));
+            }
+            else if (part.match(/^\[(\d+)\]$/)) {
+                const idx = parseInt(part.slice(1, -1));
+                if (Array.isArray(item) && item[idx] !== undefined)
+                    next.push(item[idx]);
+            }
+            else {
+                if (item && typeof item === 'object' && part in item)
+                    next.push(item[part]);
+            }
+        }
+        current = next;
+    }
+    return current;
+}
+function createJsonServer() {
+    return {
+        name: 'json',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'json_query',
+                description: 'Query JSON data using dot-notation path (e.g. "users.0.name", "items.*")',
+                inputSchema: { type: 'object', properties: { data: { description: 'JSON string or object' }, path: { type: 'string', description: 'Dot-notation path' } }, required: ['data', 'path'] },
+                handler: async (args) => {
+                    const obj = typeof args.data === 'string' ? JSON.parse(args.data) : args.data;
+                    return { results: jsonPathQuery(obj, args.path) };
+                },
+            },
+            {
+                name: 'json_transform',
+                description: 'Transform JSON: pick fields, rename keys, flatten',
+                inputSchema: { type: 'object', properties: { data: {}, operation: { type: 'string', enum: ['pick', 'omit', 'flatten', 'keys', 'values'] }, fields: { type: 'array', items: { type: 'string' } } }, required: ['data', 'operation'] },
+                handler: async (args) => {
+                    const obj = typeof args.data === 'string' ? JSON.parse(args.data) : args.data;
+                    switch (args.operation) {
+                        case 'pick': {
+                            const result = {};
+                            for (const f of args.fields || [])
+                                if (f in obj)
+                                    result[f] = obj[f];
+                            return { result };
+                        }
+                        case 'omit': {
+                            const result = { ...obj };
+                            for (const f of args.fields || [])
+                                delete result[f];
+                            return { result };
+                        }
+                        case 'flatten': {
+                            const result = {};
+                            const recurse = (o, prefix) => {
+                                for (const [k, v] of Object.entries(o)) {
+                                    const key = prefix ? `${prefix}.${k}` : k;
+                                    if (v && typeof v === 'object' && !Array.isArray(v))
+                                        recurse(v, key);
+                                    else
+                                        result[key] = v;
+                                }
+                            };
+                            recurse(obj, '');
+                            return { result };
+                        }
+                        case 'keys': return { result: Object.keys(obj) };
+                        case 'values': return { result: Object.values(obj) };
+                        default: throw new Error(`Unknown operation: ${args.operation}`);
+                    }
+                },
+            },
+            {
+                name: 'json_validate',
+                description: 'Check if a string is valid JSON',
+                inputSchema: { type: 'object', properties: { data: { type: 'string' } }, required: ['data'] },
+                handler: async (args) => {
+                    try {
+                        JSON.parse(args.data);
+                        return { valid: true };
+                    }
+                    catch (e) {
+                        return { valid: false, error: e.message };
+                    }
+                },
+            },
+            {
+                name: 'json_diff',
+                description: 'Compare two JSON objects and return differences',
+                inputSchema: { type: 'object', properties: { a: {}, b: {} }, required: ['a', 'b'] },
+                handler: async (args) => {
+                    const a = typeof args.a === 'string' ? JSON.parse(args.a) : args.a;
+                    const b = typeof args.b === 'string' ? JSON.parse(args.b) : args.b;
+                    const diffs = [];
+                    const compare = (x, y, path) => {
+                        if (x === y)
+                            return;
+                        if (typeof x !== typeof y || typeof x !== 'object' || !x || !y) {
+                            diffs.push({ path, a: x, b: y });
+                            return;
+                        }
+                        const keys = new Set([...Object.keys(x), ...Object.keys(y)]);
+                        for (const k of keys)
+                            compare(x[k], y[k], path ? `${path}.${k}` : k);
+                    };
+                    compare(a, b, '');
+                    return { equal: diffs.length === 0, differences: diffs };
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=json-mcp.js.map

package/dist/mcp/servers/memory-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createMemoryServer(): MCPServerConfig;
+//# sourceMappingURL=memory-mcp.d.ts.map

package/dist/mcp/servers/memory-mcp.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryServer = createMemoryServer;
+function createMemoryServer() {
+    const store = new Map();
+    return {
+        name: 'memory',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'memory_store',
+                description: 'Store a key-value pair in memory with optional tags',
+                inputSchema: { type: 'object', properties: { key: { type: 'string' }, value: { type: 'any' }, tags: { type: 'array', items: { type: 'string' } } }, required: ['key', 'value'] },
+                handler: async (args) => {
+                    const now = new Date().toISOString();
+                    const existing = store.get(args.key);
+                    store.set(args.key, { value: args.value, tags: args.tags || [], created: existing?.created || now, updated: now });
+                    return { stored: args.key };
+                },
+            },
+            {
+                name: 'memory_recall',
+                description: 'Recall a value by key',
+                inputSchema: { type: 'object', properties: { key: { type: 'string' } }, required: ['key'] },
+                handler: async (args) => {
+                    const entry = store.get(args.key);
+                    if (!entry)
+                        return { found: false };
+                    return { found: true, ...entry };
+                },
+            },
+            {
+                name: 'memory_search',
+                description: 'Search memory entries by tag or substring in key',
+                inputSchema: { type: 'object', properties: { query: { type: 'string' }, tag: { type: 'string' } }, required: [] },
+                handler: async (args) => {
+                    let results = Array.from(store.entries()).map(([k, v]) => ({ key: k, ...v }));
+                    if (args.tag)
+                        results = results.filter(r => r.tags.includes(args.tag));
+                    if (args.query)
+                        results = results.filter(r => r.key.includes(args.query) || JSON.stringify(r.value).includes(args.query));
+                    return { results, count: results.length };
+                },
+            },
+            {
+                name: 'memory_delete',
+                description: 'Delete a memory entry',
+                inputSchema: { type: 'object', properties: { key: { type: 'string' } }, required: ['key'] },
+                handler: async (args) => ({ deleted: store.delete(args.key) }),
+            },
+            {
+                name: 'memory_list',
+                description: 'List all memory keys',
+                inputSchema: { type: 'object', properties: {} },
+                handler: async () => ({ keys: Array.from(store.keys()), count: store.size }),
+            },
+        ],
+    };
+}
+//# sourceMappingURL=memory-mcp.js.map

package/dist/mcp/servers/regex-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createRegexServer(): MCPServerConfig;
+//# sourceMappingURL=regex-mcp.d.ts.map

package/dist/mcp/servers/regex-mcp.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegexServer = createRegexServer;
+function createRegexServer() {
+    return {
+        name: 'regex',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'regex_test',
+                description: 'Test if a string matches a regex pattern',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, flags: { type: 'string', default: '' }, text: { type: 'string' } }, required: ['pattern', 'text'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern, args.flags || '');
+                    return { matches: re.test(args.text), pattern: args.pattern };
+                },
+            },
+            {
+                name: 'regex_match',
+                description: 'Find all matches of a regex in text',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, flags: { type: 'string', default: 'g' }, text: { type: 'string' } }, required: ['pattern', 'text'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern, args.flags || 'g');
+                    const matches = [];
+                    let m;
+                    while ((m = re.exec(args.text)) !== null) {
+                        matches.push({ match: m[0], index: m.index, groups: m.groups });
+                        if (!re.global)
+                            break;
+                    }
+                    return { matches, count: matches.length };
+                },
+            },
+            {
+                name: 'regex_replace',
+                description: 'Replace matches in text using regex',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, flags: { type: 'string', default: 'g' }, text: { type: 'string' }, replacement: { type: 'string' } }, required: ['pattern', 'text', 'replacement'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern, args.flags || 'g');
+                    return { result: args.text.replace(re, args.replacement) };
+                },
+            },
+            {
+                name: 'regex_split',
+                description: 'Split text by regex pattern',
+                inputSchema: { type: 'object', properties: { pattern: { type: 'string' }, text: { type: 'string' }, limit: { type: 'number' } }, required: ['pattern', 'text'] },
+                handler: async (args) => {
+                    const re = new RegExp(args.pattern);
+                    const parts = args.text.split(re, args.limit);
+                    return { parts, count: parts.length };
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=regex-mcp.js.map

package/dist/mcp/servers/web-mcp.d.ts

@@ -0,0 +1,3 @@
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+export declare function createWebServer(): MCPServerConfig;
+//# sourceMappingURL=web-mcp.d.ts.map

package/dist/mcp/servers/web-mcp.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebServer = createWebServer;
+function createWebServer() {
+    return {
+        name: 'web',
+        version: '1.0.0',
+        tools: [
+            {
+                name: 'web_fetch',
+                description: 'Fetch a URL and return its content',
+                inputSchema: { type: 'object', properties: { url: { type: 'string' }, method: { type: 'string', default: 'GET' }, headers: { type: 'object' }, body: { type: 'string' } }, required: ['url'] },
+                handler: async (args) => {
+                    const res = await fetch(args.url, { method: args.method || 'GET', headers: args.headers, body: args.body });
+                    const contentType = res.headers.get('content-type') || '';
+                    const text = await res.text();
+                    return { status: res.status, contentType, body: text.slice(0, 50000), truncated: text.length > 50000 };
+                },
+            },
+            {
+                name: 'web_extract_text',
+                description: 'Fetch a URL and extract readable text (strips HTML tags)',
+                inputSchema: { type: 'object', properties: { url: { type: 'string' } }, required: ['url'] },
+                handler: async (args) => {
+                    const res = await fetch(args.url);
+                    const html = await res.text();
+                    const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+                    return { text: text.slice(0, 30000), truncated: text.length > 30000 };
+                },
+            },
+            {
+                name: 'web_search',
+                description: 'Search the web (simulated — returns search URL for manual use)',
+                inputSchema: { type: 'object', properties: { query: { type: 'string' }, engine: { type: 'string', enum: ['google', 'bing', 'duckduckgo'], default: 'duckduckgo' } }, required: ['query'] },
+                handler: async (args) => {
+                    const engines = {
+                        google: `https://www.google.com/search?q=${encodeURIComponent(args.query)}`,
+                        bing: `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`,
+                        duckduckgo: `https://html.duckduckgo.com/html/?q=${encodeURIComponent(args.query)}`,
+                    };
+                    const url = engines[args.engine || 'duckduckgo'];
+                    const res = await fetch(url, { headers: { 'User-Agent': 'Mozilla/5.0 opc-mcp/1.0' } });
+                    const html = await res.text();
+                    const text = html.replace(/<script[\s\S]*?<\/script>/gi, '').replace(/<style[\s\S]*?<\/style>/gi, '').replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
+                    return { query: args.query, engine: args.engine || 'duckduckgo', results: text.slice(0, 20000) };
+                },
+            },
+        ],
+    };
+}
+//# sourceMappingURL=web-mcp.js.map