opc-agent 4.1.0 → 4.1.1

package/src/tools/builtin/datetime.ts

@@ -1,41 +1,41 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const datetimeTool: MCPTool = {
-  name: 'datetime',
-  description: 'Get current date, time, timezone info',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      format: { type: 'string', default: 'iso' },
-      timezone: { type: 'string' },
-    },
-  },
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const now = new Date();
-    const timezone = input.timezone as string | undefined;
-    const format = (input.format as string) || 'iso';
-
-    let content: string;
-    if (format === 'iso') {
-      content = now.toISOString();
-    } else if (format === 'locale') {
-      content = timezone
-        ? now.toLocaleString('en-US', { timeZone: timezone })
-        : now.toLocaleString();
-    } else if (format === 'unix') {
-      content = String(Math.floor(now.getTime() / 1000));
-    } else {
-      content = now.toISOString();
-    }
-
-    return {
-      content: JSON.stringify({
-        iso: now.toISOString(),
-        unix: Math.floor(now.getTime() / 1000),
-        formatted: content,
-        timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
-      }),
-      isError: false,
-    };
-  },
-};
+import type { MCPTool, MCPToolResult } from '../mcp';
+
+export const datetimeTool: MCPTool = {
+  name: 'datetime',
+  description: 'Get current date, time, timezone info',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      format: { type: 'string', default: 'iso' },
+      timezone: { type: 'string' },
+    },
+  },
+  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
+    const now = new Date();
+    const timezone = input.timezone as string | undefined;
+    const format = (input.format as string) || 'iso';
+
+    let content: string;
+    if (format === 'iso') {
+      content = now.toISOString();
+    } else if (format === 'locale') {
+      content = timezone
+        ? now.toLocaleString('en-US', { timeZone: timezone })
+        : now.toLocaleString();
+    } else if (format === 'unix') {
+      content = String(Math.floor(now.getTime() / 1000));
+    } else {
+      content = now.toISOString();
+    }
+
+    return {
+      content: JSON.stringify({
+        iso: now.toISOString(),
+        unix: Math.floor(now.getTime() / 1000),
+        formatted: content,
+        timezone: timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+      }),
+      isError: false,
+    };
+  },
+};

package/src/tools/builtin/file.ts

@@ -1,107 +1,107 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { MCPTool, MCPToolResult } from '../mcp';
-import type { AgentContext } from '../../core/types';
-
-function resolveSafe(basePath: string, targetPath: string): string | null {
-  const resolved = path.resolve(basePath, targetPath);
-  if (!resolved.startsWith(path.resolve(basePath))) return null;
-  return resolved;
-}
-
-function searchFiles(dir: string, query: string, results: string[] = [], maxResults = 20): string[] {
-  if (results.length >= maxResults) return results;
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (results.length >= maxResults) break;
-      const full = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (entry.name === 'node_modules' || entry.name === '.git') continue;
-        searchFiles(full, query, results, maxResults);
-      } else if (entry.isFile()) {
-        try {
-          const content = fs.readFileSync(full, 'utf-8');
-          const lines = content.split('\n');
-          for (let i = 0; i < lines.length; i++) {
-            if (lines[i].includes(query)) {
-              results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
-              if (results.length >= maxResults) break;
-            }
-          }
-        } catch { /* skip binary/unreadable */ }
-      }
-    }
-  } catch { /* skip inaccessible dirs */ }
-  return results;
-}
-
-export const fileTool: MCPTool = {
-  name: 'file_operations',
-  description: 'Read, write, list, and search files in the workspace',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['read', 'write', 'list', 'search', 'exists'] },
-      path: { type: 'string' },
-      content: { type: 'string' },
-      query: { type: 'string' },
-    },
-    required: ['action'],
-  },
-  async execute(input: Record<string, unknown>, context?: AgentContext): Promise<MCPToolResult> {
-    const action = input.action as string;
-    const workspace = process.cwd();
-    const targetPath = input.path as string | undefined;
-
-    if (action === 'search') {
-      const query = input.query as string;
-      if (!query) return { content: 'query is required for search', isError: true };
-      const results = searchFiles(workspace, query);
-      return { content: results.length ? results.join('\n') : 'No matches found', isError: false };
-    }
-
-    if (action === 'list') {
-      const dir = targetPath ? resolveSafe(workspace, targetPath) : workspace;
-      if (!dir) return { content: 'Path outside workspace', isError: true };
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        const listing = entries.map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`).join('\n');
-        return { content: listing || '(empty directory)', isError: false };
-      } catch (err) {
-        return { content: `Error listing directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
-      }
-    }
-
-    if (!targetPath) return { content: 'path is required', isError: true };
-    const resolved = resolveSafe(workspace, targetPath);
-    if (!resolved) return { content: 'Path outside workspace', isError: true };
-
-    switch (action) {
-      case 'read': {
-        try {
-          const content = fs.readFileSync(resolved, 'utf-8');
-          return { content: content.slice(0, 50000), isError: false };
-        } catch (err) {
-          return { content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
-        }
-      }
-      case 'write': {
-        const content = input.content as string;
-        if (content === undefined) return { content: 'content is required for write', isError: true };
-        try {
-          fs.mkdirSync(path.dirname(resolved), { recursive: true });
-          fs.writeFileSync(resolved, content, 'utf-8');
-          return { content: `Written ${content.length} bytes to ${targetPath}`, isError: false };
-        } catch (err) {
-          return { content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
-        }
-      }
-      case 'exists': {
-        return { content: String(fs.existsSync(resolved)), isError: false };
-      }
-      default:
-        return { content: `Unknown action: ${action}`, isError: true };
-    }
-  },
-};
+import * as fs from 'fs';
+import * as path from 'path';
+import type { MCPTool, MCPToolResult } from '../mcp';
+import type { AgentContext } from '../../core/types';
+
+function resolveSafe(basePath: string, targetPath: string): string | null {
+  const resolved = path.resolve(basePath, targetPath);
+  if (!resolved.startsWith(path.resolve(basePath))) return null;
+  return resolved;
+}
+
+function searchFiles(dir: string, query: string, results: string[] = [], maxResults = 20): string[] {
+  if (results.length >= maxResults) return results;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (results.length >= maxResults) break;
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === 'node_modules' || entry.name === '.git') continue;
+        searchFiles(full, query, results, maxResults);
+      } else if (entry.isFile()) {
+        try {
+          const content = fs.readFileSync(full, 'utf-8');
+          const lines = content.split('\n');
+          for (let i = 0; i < lines.length; i++) {
+            if (lines[i].includes(query)) {
+              results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
+              if (results.length >= maxResults) break;
+            }
+          }
+        } catch { /* skip binary/unreadable */ }
+      }
+    }
+  } catch { /* skip inaccessible dirs */ }
+  return results;
+}
+
+export const fileTool: MCPTool = {
+  name: 'file_operations',
+  description: 'Read, write, list, and search files in the workspace',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', enum: ['read', 'write', 'list', 'search', 'exists'] },
+      path: { type: 'string' },
+      content: { type: 'string' },
+      query: { type: 'string' },
+    },
+    required: ['action'],
+  },
+  async execute(input: Record<string, unknown>, context?: AgentContext): Promise<MCPToolResult> {
+    const action = input.action as string;
+    const workspace = process.cwd();
+    const targetPath = input.path as string | undefined;
+
+    if (action === 'search') {
+      const query = input.query as string;
+      if (!query) return { content: 'query is required for search', isError: true };
+      const results = searchFiles(workspace, query);
+      return { content: results.length ? results.join('\n') : 'No matches found', isError: false };
+    }
+
+    if (action === 'list') {
+      const dir = targetPath ? resolveSafe(workspace, targetPath) : workspace;
+      if (!dir) return { content: 'Path outside workspace', isError: true };
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const listing = entries.map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`).join('\n');
+        return { content: listing || '(empty directory)', isError: false };
+      } catch (err) {
+        return { content: `Error listing directory: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+      }
+    }
+
+    if (!targetPath) return { content: 'path is required', isError: true };
+    const resolved = resolveSafe(workspace, targetPath);
+    if (!resolved) return { content: 'Path outside workspace', isError: true };
+
+    switch (action) {
+      case 'read': {
+        try {
+          const content = fs.readFileSync(resolved, 'utf-8');
+          return { content: content.slice(0, 50000), isError: false };
+        } catch (err) {
+          return { content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+        }
+      }
+      case 'write': {
+        const content = input.content as string;
+        if (content === undefined) return { content: 'content is required for write', isError: true };
+        try {
+          fs.mkdirSync(path.dirname(resolved), { recursive: true });
+          fs.writeFileSync(resolved, content, 'utf-8');
+          return { content: `Written ${content.length} bytes to ${targetPath}`, isError: false };
+        } catch (err) {
+          return { content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`, isError: true };
+        }
+      }
+      case 'exists': {
+        return { content: String(fs.existsSync(resolved)), isError: false };
+      }
+      default:
+        return { content: `Unknown action: ${action}`, isError: true };
+    }
+  },
+};

package/src/tools/builtin/home-assistant.ts

@@ -1,116 +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];
+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];