opc-agent 4.1.0 → 4.1.1

package/src/tools/integrations/csv-analyzer.ts

@@ -1,92 +1,92 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-import * as fs from 'fs';
-
-export const CSVAnalyzerTool: MCPTool = {
-  name: 'csv-analyzer',
-  description: 'Parse, filter, and aggregate CSV data from a file or inline text.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      file_path: { type: 'string', description: 'Path to CSV file' },
-      data: { type: 'string', description: 'Inline CSV data (alternative to file_path)' },
-      action: { type: 'string', enum: ['parse', 'filter', 'aggregate'], description: 'Action (default: parse)' },
-      column: { type: 'string', description: 'Column name (for filter/aggregate)' },
-      value: { type: 'string', description: 'Filter value' },
-      operation: { type: 'string', enum: ['sum', 'avg', 'min', 'max', 'count'], description: 'Aggregate operation' },
-    },
-    required: [],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    try {
-      let csvText: string;
-      if (input.file_path) {
-        csvText = fs.readFileSync(String(input.file_path), 'utf-8');
-      } else if (input.data) {
-        csvText = String(input.data);
-      } else {
-        return { content: 'Error: file_path or data required', isError: true };
-      }
-
-      const lines = csvText.trim().split(/\r?\n/);
-      if (lines.length < 2) return { content: 'Error: CSV must have at least a header and one data row', isError: true };
-
-      const headers = parseCsvLine(lines[0]);
-      const rows = lines.slice(1).map(parseCsvLine);
-      const action = String(input.action ?? 'parse');
-
-      if (action === 'parse') {
-        const preview = rows.slice(0, 20).map((r) => {
-          const obj: Record<string, string> = {};
-          headers.forEach((h, i) => obj[h] = r[i] ?? '');
-          return obj;
-        });
-        return { content: `${headers.join(', ')}\n${rows.length} rows\n\n${JSON.stringify(preview, null, 2).slice(0, 3000)}` };
-      }
-
-      if (action === 'filter') {
-        const col = String(input.column ?? '');
-        const colIdx = headers.indexOf(col);
-        if (colIdx === -1) return { content: `Column not found: ${col}. Available: ${headers.join(', ')}`, isError: true };
-        const filtered = rows.filter((r) => r[colIdx] === String(input.value ?? ''));
-        return { content: `${filtered.length} matching rows\n${JSON.stringify(filtered.slice(0, 20), null, 2).slice(0, 3000)}` };
-      }
-
-      if (action === 'aggregate') {
-        const col = String(input.column ?? '');
-        const colIdx = headers.indexOf(col);
-        if (colIdx === -1) return { content: `Column not found: ${col}`, isError: true };
-        const values = rows.map((r) => parseFloat(r[colIdx])).filter((v) => !isNaN(v));
-        const op = String(input.operation ?? 'count');
-        let result: number;
-        switch (op) {
-          case 'sum': result = values.reduce((a, b) => a + b, 0); break;
-          case 'avg': result = values.reduce((a, b) => a + b, 0) / values.length; break;
-          case 'min': result = Math.min(...values); break;
-          case 'max': result = Math.max(...values); break;
-          case 'count': result = values.length; break;
-          default: return { content: `Unknown operation: ${op}`, isError: true };
-        }
-        return { content: `${op}(${col}) = ${result}` };
-      }
-
-      return { content: `Unknown action: ${action}`, isError: true };
-    } catch (err) {
-      return { content: `CSV error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};
-
-function parseCsvLine(line: string): string[] {
-  const result: string[] = [];
-  let current = '';
-  let inQuotes = false;
-  for (let i = 0; i < line.length; i++) {
-    const ch = line[i];
-    if (ch === '"') { inQuotes = !inQuotes; }
-    else if (ch === ',' && !inQuotes) { result.push(current.trim()); current = ''; }
-    else { current += ch; }
-  }
-  result.push(current.trim());
-  return result;
-}
+import type { MCPTool, MCPToolResult } from '../mcp';
+import * as fs from 'fs';
+
+export const CSVAnalyzerTool: MCPTool = {
+  name: 'csv-analyzer',
+  description: 'Parse, filter, and aggregate CSV data from a file or inline text.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      file_path: { type: 'string', description: 'Path to CSV file' },
+      data: { type: 'string', description: 'Inline CSV data (alternative to file_path)' },
+      action: { type: 'string', enum: ['parse', 'filter', 'aggregate'], description: 'Action (default: parse)' },
+      column: { type: 'string', description: 'Column name (for filter/aggregate)' },
+      value: { type: 'string', description: 'Filter value' },
+      operation: { type: 'string', enum: ['sum', 'avg', 'min', 'max', 'count'], description: 'Aggregate operation' },
+    },
+    required: [],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    try {
+      let csvText: string;
+      if (input.file_path) {
+        csvText = fs.readFileSync(String(input.file_path), 'utf-8');
+      } else if (input.data) {
+        csvText = String(input.data);
+      } else {
+        return { content: 'Error: file_path or data required', isError: true };
+      }
+
+      const lines = csvText.trim().split(/\r?\n/);
+      if (lines.length < 2) return { content: 'Error: CSV must have at least a header and one data row', isError: true };
+
+      const headers = parseCsvLine(lines[0]);
+      const rows = lines.slice(1).map(parseCsvLine);
+      const action = String(input.action ?? 'parse');
+
+      if (action === 'parse') {
+        const preview = rows.slice(0, 20).map((r) => {
+          const obj: Record<string, string> = {};
+          headers.forEach((h, i) => obj[h] = r[i] ?? '');
+          return obj;
+        });
+        return { content: `${headers.join(', ')}\n${rows.length} rows\n\n${JSON.stringify(preview, null, 2).slice(0, 3000)}` };
+      }
+
+      if (action === 'filter') {
+        const col = String(input.column ?? '');
+        const colIdx = headers.indexOf(col);
+        if (colIdx === -1) return { content: `Column not found: ${col}. Available: ${headers.join(', ')}`, isError: true };
+        const filtered = rows.filter((r) => r[colIdx] === String(input.value ?? ''));
+        return { content: `${filtered.length} matching rows\n${JSON.stringify(filtered.slice(0, 20), null, 2).slice(0, 3000)}` };
+      }
+
+      if (action === 'aggregate') {
+        const col = String(input.column ?? '');
+        const colIdx = headers.indexOf(col);
+        if (colIdx === -1) return { content: `Column not found: ${col}`, isError: true };
+        const values = rows.map((r) => parseFloat(r[colIdx])).filter((v) => !isNaN(v));
+        const op = String(input.operation ?? 'count');
+        let result: number;
+        switch (op) {
+          case 'sum': result = values.reduce((a, b) => a + b, 0); break;
+          case 'avg': result = values.reduce((a, b) => a + b, 0) / values.length; break;
+          case 'min': result = Math.min(...values); break;
+          case 'max': result = Math.max(...values); break;
+          case 'count': result = values.length; break;
+          default: return { content: `Unknown operation: ${op}`, isError: true };
+        }
+        return { content: `${op}(${col}) = ${result}` };
+      }
+
+      return { content: `Unknown action: ${action}`, isError: true };
+    } catch (err) {
+      return { content: `CSV error: ${(err as Error).message}`, isError: true };
+    }
+  },
+};
+
+function parseCsvLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') { inQuotes = !inQuotes; }
+    else if (ch === ',' && !inQuotes) { result.push(current.trim()); current = ''; }
+    else { current += ch; }
+  }
+  result.push(current.trim());
+  return result;
+}

package/src/tools/integrations/database.ts

@@ -1,44 +1,44 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-import { execSync } from 'child_process';
-
-export const DatabaseTool: MCPTool = {
-  name: 'database',
-  description: 'Execute SQL queries against a database. Supports SQLite (via CLI), PostgreSQL, MySQL via connection URL. Set DATABASE_URL env var.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: { type: 'string', description: 'SQL query to execute' },
-      connection_url: { type: 'string', description: 'Connection URL (overrides DATABASE_URL)' },
-    },
-    required: ['query'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const query = String(input.query ?? '');
-    if (!query) return { content: 'Error: query required', isError: true };
-
-    // Safety check: block destructive operations unless explicitly allowed
-    const dangerous = /^\s*(DROP|DELETE|TRUNCATE|ALTER)\s/i;
-    if (dangerous.test(query) && !process.env.DATABASE_ALLOW_DESTRUCTIVE) {
-      return { content: 'Error: Destructive queries blocked. Set DATABASE_ALLOW_DESTRUCTIVE=1 to allow.', isError: true };
-    }
-
-    const url = String(input.connection_url ?? process.env.DATABASE_URL ?? '');
-    if (!url) return { content: 'Error: connection_url or DATABASE_URL required', isError: true };
-
-    try {
-      if (url.startsWith('sqlite:') || url.endsWith('.db') || url.endsWith('.sqlite')) {
-        const dbPath = url.replace(/^sqlite:\/\//, '').replace(/^sqlite:/, '');
-        const result = execSync(`sqlite3 -header -csv "${dbPath}" "${query.replace(/"/g, '\\"')}"`, {
-          timeout: 30000, encoding: 'utf-8', maxBuffer: 1024 * 1024,
-        });
-        return { content: result.slice(0, 4000) || '(no results)' };
-      }
-
-      // For Postgres/MySQL, attempt using native TCP (simplified — real impl would need protocol handling)
-      return { content: 'Error: Only SQLite is supported without external packages. For Postgres/MySQL, install appropriate drivers.', isError: true };
-    } catch (err) {
-      return { content: `Database error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};
+import type { MCPTool, MCPToolResult } from '../mcp';
+import { execSync } from 'child_process';
+
+export const DatabaseTool: MCPTool = {
+  name: 'database',
+  description: 'Execute SQL queries against a database. Supports SQLite (via CLI), PostgreSQL, MySQL via connection URL. Set DATABASE_URL env var.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'SQL query to execute' },
+      connection_url: { type: 'string', description: 'Connection URL (overrides DATABASE_URL)' },
+    },
+    required: ['query'],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const query = String(input.query ?? '');
+    if (!query) return { content: 'Error: query required', isError: true };
+
+    // Safety check: block destructive operations unless explicitly allowed
+    const dangerous = /^\s*(DROP|DELETE|TRUNCATE|ALTER)\s/i;
+    if (dangerous.test(query) && !process.env.DATABASE_ALLOW_DESTRUCTIVE) {
+      return { content: 'Error: Destructive queries blocked. Set DATABASE_ALLOW_DESTRUCTIVE=1 to allow.', isError: true };
+    }
+
+    const url = String(input.connection_url ?? process.env.DATABASE_URL ?? '');
+    if (!url) return { content: 'Error: connection_url or DATABASE_URL required', isError: true };
+
+    try {
+      if (url.startsWith('sqlite:') || url.endsWith('.db') || url.endsWith('.sqlite')) {
+        const dbPath = url.replace(/^sqlite:\/\//, '').replace(/^sqlite:/, '');
+        const result = execSync(`sqlite3 -header -csv "${dbPath}" "${query.replace(/"/g, '\\"')}"`, {
+          timeout: 30000, encoding: 'utf-8', maxBuffer: 1024 * 1024,
+        });
+        return { content: result.slice(0, 4000) || '(no results)' };
+      }
+
+      // For Postgres/MySQL, attempt using native TCP (simplified — real impl would need protocol handling)
+      return { content: 'Error: Only SQLite is supported without external packages. For Postgres/MySQL, install appropriate drivers.', isError: true };
+    } catch (err) {
+      return { content: `Database error: ${(err as Error).message}`, isError: true };
+    }
+  },
+};

package/src/tools/integrations/email-send.ts

@@ -1,76 +1,76 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-import * as net from 'net';
-import * as tls from 'tls';
-
-export const EmailSendTool: MCPTool = {
-  name: 'email-send',
-  description: 'Send email via SMTP. Requires SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS env vars.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      to: { type: 'string', description: 'Recipient email address' },
-      subject: { type: 'string', description: 'Email subject' },
-      body: { type: 'string', description: 'Email body (plain text)' },
-      from: { type: 'string', description: 'Sender email (defaults to SMTP_USER)' },
-    },
-    required: ['to', 'subject', 'body'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const host = process.env.SMTP_HOST;
-    const port = parseInt(process.env.SMTP_PORT || '587', 10);
-    const user = process.env.SMTP_USER;
-    const pass = process.env.SMTP_PASS;
-
-    if (!host || !user || !pass) {
-      return { content: 'Error: SMTP_HOST, SMTP_USER, SMTP_PASS env vars required', isError: true };
-    }
-
-    const to = String(input.to ?? '');
-    const subject = String(input.subject ?? '');
-    const body = String(input.body ?? '');
-    const from = String(input.from ?? user);
-
-    if (!to || !subject) return { content: 'Error: to and subject are required', isError: true };
-
-    try {
-      await sendSmtp(host, port, user, pass, from, to, subject, body);
-      return { content: `Email sent to ${to}` };
-    } catch (err) {
-      return { content: `SMTP error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};
-
-function sendSmtp(host: string, port: number, user: string, pass: string, from: string, to: string, subject: string, body: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const commands = [
-      `EHLO localhost`,
-      `AUTH LOGIN`,
-      Buffer.from(user).toString('base64'),
-      Buffer.from(pass).toString('base64'),
-      `MAIL FROM:<${from}>`,
-      `RCPT TO:<${to}>`,
-      `DATA`,
-      `From: ${from}\r\nTo: ${to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body}\r\n.`,
-      `QUIT`,
-    ];
-
-    let idx = 0;
-    const socket = port === 465
-      ? tls.connect({ host, port, rejectUnauthorized: false })
-      : net.createConnection({ host, port });
-
-    const timeout = setTimeout(() => { socket.destroy(); reject(new Error('SMTP timeout')); }, 30000);
-
-    socket.setEncoding('utf8');
-    socket.on('data', () => {
-      if (idx < commands.length) {
-        socket.write(commands[idx] + '\r\n');
-        idx++;
-      }
-    });
-    socket.on('end', () => { clearTimeout(timeout); resolve(); });
-    socket.on('error', (err) => { clearTimeout(timeout); reject(err); });
-  });
-}
+import type { MCPTool, MCPToolResult } from '../mcp';
+import * as net from 'net';
+import * as tls from 'tls';
+
+export const EmailSendTool: MCPTool = {
+  name: 'email-send',
+  description: 'Send email via SMTP. Requires SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASS env vars.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      to: { type: 'string', description: 'Recipient email address' },
+      subject: { type: 'string', description: 'Email subject' },
+      body: { type: 'string', description: 'Email body (plain text)' },
+      from: { type: 'string', description: 'Sender email (defaults to SMTP_USER)' },
+    },
+    required: ['to', 'subject', 'body'],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const host = process.env.SMTP_HOST;
+    const port = parseInt(process.env.SMTP_PORT || '587', 10);
+    const user = process.env.SMTP_USER;
+    const pass = process.env.SMTP_PASS;
+
+    if (!host || !user || !pass) {
+      return { content: 'Error: SMTP_HOST, SMTP_USER, SMTP_PASS env vars required', isError: true };
+    }
+
+    const to = String(input.to ?? '');
+    const subject = String(input.subject ?? '');
+    const body = String(input.body ?? '');
+    const from = String(input.from ?? user);
+
+    if (!to || !subject) return { content: 'Error: to and subject are required', isError: true };
+
+    try {
+      await sendSmtp(host, port, user, pass, from, to, subject, body);
+      return { content: `Email sent to ${to}` };
+    } catch (err) {
+      return { content: `SMTP error: ${(err as Error).message}`, isError: true };
+    }
+  },
+};
+
+function sendSmtp(host: string, port: number, user: string, pass: string, from: string, to: string, subject: string, body: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const commands = [
+      `EHLO localhost`,
+      `AUTH LOGIN`,
+      Buffer.from(user).toString('base64'),
+      Buffer.from(pass).toString('base64'),
+      `MAIL FROM:<${from}>`,
+      `RCPT TO:<${to}>`,
+      `DATA`,
+      `From: ${from}\r\nTo: ${to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n${body}\r\n.`,
+      `QUIT`,
+    ];
+
+    let idx = 0;
+    const socket = port === 465
+      ? tls.connect({ host, port, rejectUnauthorized: false })
+      : net.createConnection({ host, port });
+
+    const timeout = setTimeout(() => { socket.destroy(); reject(new Error('SMTP timeout')); }, 30000);
+
+    socket.setEncoding('utf8');
+    socket.on('data', () => {
+      if (idx < commands.length) {
+        socket.write(commands[idx] + '\r\n');
+        idx++;
+      }
+    });
+    socket.on('end', () => { clearTimeout(timeout); resolve(); });
+    socket.on('error', (err) => { clearTimeout(timeout); reject(err); });
+  });
+}

package/src/tools/integrations/git-tool.ts

@@ -1,42 +1,42 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-import { execSync } from 'child_process';
-
-export const GitTool: MCPTool = {
-  name: 'git',
-  description: 'Run git commands on a local repository: status, diff, commit, log.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['status', 'diff', 'commit', 'log'], description: 'Git action' },
-      cwd: { type: 'string', description: 'Repository directory path' },
-      message: { type: 'string', description: 'Commit message (for commit)' },
-      args: { type: 'string', description: 'Additional git arguments' },
-    },
-    required: ['action'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const action = String(input.action ?? '');
-    const cwd = String(input.cwd ?? process.cwd());
-    const args = String(input.args ?? '');
-
-    try {
-      let cmd: string;
-      switch (action) {
-        case 'status': cmd = `git status --short ${args}`; break;
-        case 'diff': cmd = `git diff ${args}`; break;
-        case 'commit':
-          if (!input.message) return { content: 'Error: message required for commit', isError: true };
-          cmd = `git add -A && git commit -m ${JSON.stringify(String(input.message))} ${args}`;
-          break;
-        case 'log': cmd = `git log --oneline -20 ${args}`; break;
-        default: return { content: `Unknown action: ${action}`, isError: true };
-      }
-
-      const result = execSync(cmd, { cwd, timeout: 30000, encoding: 'utf-8', maxBuffer: 1024 * 1024 });
-      return { content: result.slice(0, 4000) || '(clean)' };
-    } catch (err) {
-      return { content: `Git error: ${(err as Error).message.slice(0, 1000)}`, isError: true };
-    }
-  },
-};
+import type { MCPTool, MCPToolResult } from '../mcp';
+import { execSync } from 'child_process';
+
+export const GitTool: MCPTool = {
+  name: 'git',
+  description: 'Run git commands on a local repository: status, diff, commit, log.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['status', 'diff', 'commit', 'log'], description: 'Git action' },
+      cwd: { type: 'string', description: 'Repository directory path' },
+      message: { type: 'string', description: 'Commit message (for commit)' },
+      args: { type: 'string', description: 'Additional git arguments' },
+    },
+    required: ['action'],
+  },
+
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const action = String(input.action ?? '');
+    const cwd = String(input.cwd ?? process.cwd());
+    const args = String(input.args ?? '');
+
+    try {
+      let cmd: string;
+      switch (action) {
+        case 'status': cmd = `git status --short ${args}`; break;
+        case 'diff': cmd = `git diff ${args}`; break;
+        case 'commit':
+          if (!input.message) return { content: 'Error: message required for commit', isError: true };
+          cmd = `git add -A && git commit -m ${JSON.stringify(String(input.message))} ${args}`;
+          break;
+        case 'log': cmd = `git log --oneline -20 ${args}`; break;
+        default: return { content: `Unknown action: ${action}`, isError: true };
+      }
+
+      const result = execSync(cmd, { cwd, timeout: 30000, encoding: 'utf-8', maxBuffer: 1024 * 1024 });
+      return { content: result.slice(0, 4000) || '(clean)' };
+    } catch (err) {
+      return { content: `Git error: ${(err as Error).message.slice(0, 1000)}`, isError: true };
+    }
+  },
+};