opc-agent 4.0.44 → 4.1.1

package/src/mcp/servers/json-mcp.ts

@@ -1,102 +1,102 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-function jsonPathQuery(obj: any, path: string): any[] {
-  const parts = path.replace(/^\$\.?/, '').split('.');
-  let current: any[] = [obj];
-  for (const part of parts) {
-    if (!part) continue;
-    const next: any[] = [];
-    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;
-}
-
-export function createJsonServer(): MCPServerConfig {
-  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: { data: any; path: string }) => {
-          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: { data: any; operation: string; fields?: string[] }) => {
-          const obj = typeof args.data === 'string' ? JSON.parse(args.data) : args.data;
-          switch (args.operation) {
-            case 'pick': {
-              const result: any = {};
-              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: Record<string, any> = {};
-              const recurse = (o: any, prefix: string) => {
-                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: { data: string }) => {
-          try { JSON.parse(args.data); return { valid: true }; } catch (e: any) { 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: { a: any; b: any }) => {
-          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: { path: string; a: any; b: any }[] = [];
-          const compare = (x: any, y: any, path: string) => {
-            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 };
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+function jsonPathQuery(obj: any, path: string): any[] {
+  const parts = path.replace(/^\$\.?/, '').split('.');
+  let current: any[] = [obj];
+  for (const part of parts) {
+    if (!part) continue;
+    const next: any[] = [];
+    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;
+}
+
+export function createJsonServer(): MCPServerConfig {
+  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: { data: any; path: string }) => {
+          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: { data: any; operation: string; fields?: string[] }) => {
+          const obj = typeof args.data === 'string' ? JSON.parse(args.data) : args.data;
+          switch (args.operation) {
+            case 'pick': {
+              const result: any = {};
+              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: Record<string, any> = {};
+              const recurse = (o: any, prefix: string) => {
+                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: { data: string }) => {
+          try { JSON.parse(args.data); return { valid: true }; } catch (e: any) { 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: { a: any; b: any }) => {
+          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: { path: string; a: any; b: any }[] = [];
+          const compare = (x: any, y: any, path: string) => {
+            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 };
+        },
+      },
+    ],
+  };
+}

package/src/mcp/servers/memory-mcp.ts

@@ -1,56 +1,56 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-export function createMemoryServer(): MCPServerConfig {
-  const store = new Map<string, { value: any; tags: string[]; created: string; updated: string }>();
-
-  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: { key: string; value: any; tags?: string[] }) => {
-          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: { key: string }) => {
-          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: { query?: string; tag?: string }) => {
-          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: { key: string }) => ({ 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 }),
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createMemoryServer(): MCPServerConfig {
+  const store = new Map<string, { value: any; tags: string[]; created: string; updated: string }>();
+
+  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: { key: string; value: any; tags?: string[] }) => {
+          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: { key: string }) => {
+          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: { query?: string; tag?: string }) => {
+          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: { key: string }) => ({ 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 }),
+      },
+    ],
+  };
+}

package/src/mcp/servers/regex-mcp.ts

@@ -1,53 +1,53 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-export function createRegexServer(): MCPServerConfig {
-  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: { pattern: string; flags?: string; text: string }) => {
-          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: { pattern: string; flags?: string; text: string }) => {
-          const re = new RegExp(args.pattern, args.flags || 'g');
-          const matches: { match: string; index: number; groups?: Record<string, string> }[] = [];
-          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: { pattern: string; flags?: string; text: string; replacement: string }) => {
-          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: { pattern: string; text: string; limit?: number }) => {
-          const re = new RegExp(args.pattern);
-          const parts = args.text.split(re, args.limit);
-          return { parts, count: parts.length };
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createRegexServer(): MCPServerConfig {
+  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: { pattern: string; flags?: string; text: string }) => {
+          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: { pattern: string; flags?: string; text: string }) => {
+          const re = new RegExp(args.pattern, args.flags || 'g');
+          const matches: { match: string; index: number; groups?: Record<string, string> }[] = [];
+          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: { pattern: string; flags?: string; text: string; replacement: string }) => {
+          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: { pattern: string; text: string; limit?: number }) => {
+          const re = new RegExp(args.pattern);
+          const parts = args.text.split(re, args.limit);
+          return { parts, count: parts.length };
+        },
+      },
+    ],
+  };
+}

package/src/mcp/servers/web-mcp.ts

@@ -1,49 +1,49 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-export function createWebServer(): MCPServerConfig {
-  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: { url: string; method?: string; headers?: Record<string, string>; body?: string }) => {
-          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: { url: string }) => {
-          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: { query: string; engine?: string }) => {
-          const engines: Record<string, string> = {
-            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) };
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createWebServer(): MCPServerConfig {
+  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: { url: string; method?: string; headers?: Record<string, string>; body?: string }) => {
+          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: { url: string }) => {
+          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: { query: string; engine?: string }) => {
+          const engines: Record<string, string> = {
+            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) };
+        },
+      },
+    ],
+  };
+}