opc-agent 4.1.2 → 4.1.4

package/src/tools/image-generator.ts

@@ -1,150 +0,0 @@
-/**
- * Image Generator — multi-backend image generation tool.
- * Supports DALL·E (OpenAI), Stable Diffusion (local), and Replicate.
- */
-
-export interface ImageGenConfig {
-  provider?: 'dalle' | 'stable-diffusion' | 'replicate';
-  openaiApiKey?: string;
-  replicateApiKey?: string;
-  sdApiUrl?: string;
-  defaultModel?: string;
-  defaultSize?: string;
-}
-
-export interface ImageGenResult {
-  success: boolean;
-  url?: string;
-  base64?: string;
-  error?: string;
-  provider: string;
-}
-
-export class ImageGenerator {
-  private config: ImageGenConfig;
-
-  constructor(config?: ImageGenConfig) {
-    this.config = {
-      provider: config?.provider,
-      openaiApiKey: config?.openaiApiKey || process.env.OPENAI_API_KEY,
-      replicateApiKey: config?.replicateApiKey || process.env.REPLICATE_API_TOKEN,
-      sdApiUrl: config?.sdApiUrl || process.env.SD_API_URL,
-      defaultModel: config?.defaultModel || 'dall-e-3',
-      defaultSize: config?.defaultSize || '1024x1024',
-    };
-  }
-
-  /** Auto-detect best available provider */
-  detectProvider(): string | null {
-    if (this.config.openaiApiKey) return 'dalle';
-    if (this.config.sdApiUrl) return 'stable-diffusion';
-    if (this.config.replicateApiKey) return 'replicate';
-    return null;
-  }
-
-  /** Get configuration status for the settings UI */
-  getStatus(): { configured: boolean; providers: { name: string; configured: boolean }[] } {
-    return {
-      configured: !!this.detectProvider(),
-      providers: [
-        { name: 'dalle', configured: !!this.config.openaiApiKey },
-        { name: 'stable-diffusion', configured: !!this.config.sdApiUrl },
-        { name: 'replicate', configured: !!this.config.replicateApiKey },
-      ],
-    };
-  }
-
-  async generate(prompt: string, options?: { provider?: string; size?: string; model?: string }): Promise<ImageGenResult> {
-    const provider = options?.provider || this.config.provider || this.detectProvider();
-    if (!provider) {
-      return { success: false, error: 'No image generation provider configured. Please set OPENAI_API_KEY, SD_API_URL, or REPLICATE_API_TOKEN.', provider: 'none' };
-    }
-
-    switch (provider) {
-      case 'dalle': return this.generateDalle(prompt, options);
-      case 'stable-diffusion': return this.generateSD(prompt, options);
-      case 'replicate': return this.generateReplicate(prompt, options);
-      default: return { success: false, error: `Unknown provider: ${provider}`, provider };
-    }
-  }
-
-  private async generateDalle(prompt: string, options?: { size?: string; model?: string }): Promise<ImageGenResult> {
-    const apiKey = this.config.openaiApiKey;
-    if (!apiKey) return { success: false, error: 'OPENAI_API_KEY not configured', provider: 'dalle' };
-
-    try {
-      const res = await fetch('https://api.openai.com/v1/images/generations', {
-        method: 'POST',
-        headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          model: options?.model || this.config.defaultModel || 'dall-e-3',
-          prompt,
-          size: options?.size || this.config.defaultSize || '1024x1024',
-          n: 1,
-        }),
-      });
-      const data = await res.json() as { data?: Array<{ url: string }>; error?: { message: string } };
-      if (data.error) return { success: false, error: data.error.message, provider: 'dalle' };
-      const url = data.data?.[0]?.url;
-      return url ? { success: true, url, provider: 'dalle' } : { success: false, error: 'No image returned', provider: 'dalle' };
-    } catch (err) {
-      return { success: false, error: (err as Error).message, provider: 'dalle' };
-    }
-  }
-
-  private async generateSD(prompt: string, options?: { size?: string }): Promise<ImageGenResult> {
-    const apiUrl = this.config.sdApiUrl;
-    if (!apiUrl) return { success: false, error: 'SD_API_URL not configured', provider: 'stable-diffusion' };
-
-    try {
-      const [w, h] = (options?.size || '1024x1024').split('x').map(Number);
-      const res = await fetch(`${apiUrl}/sdapi/v1/txt2img`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ prompt, width: w || 1024, height: h || 1024 }),
-      });
-      const data = await res.json() as { images?: string[] };
-      if (data.images?.length) {
-        return { success: true, base64: data.images[0], provider: 'stable-diffusion' };
-      }
-      return { success: false, error: 'No image generated', provider: 'stable-diffusion' };
-    } catch (err) {
-      return { success: false, error: (err as Error).message, provider: 'stable-diffusion' };
-    }
-  }
-
-  private async generateReplicate(prompt: string, _options?: { model?: string }): Promise<ImageGenResult> {
-    const apiKey = this.config.replicateApiKey;
-    if (!apiKey) return { success: false, error: 'REPLICATE_API_TOKEN not configured', provider: 'replicate' };
-
-    try {
-      const res = await fetch('https://api.replicate.com/v1/predictions', {
-        method: 'POST',
-        headers: { 'Authorization': `Token ${apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          version: 'stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b',
-          input: { prompt },
-        }),
-      });
-      const prediction = await res.json() as { id: string; urls?: { get: string }; error?: string };
-      if (prediction.error) return { success: false, error: prediction.error, provider: 'replicate' };
-
-      // Poll for completion (max 60s)
-      const getUrl = prediction.urls?.get || `https://api.replicate.com/v1/predictions/${prediction.id}`;
-      for (let i = 0; i < 30; i++) {
-        await new Promise(r => setTimeout(r, 2000));
-        const poll = await fetch(getUrl, { headers: { 'Authorization': `Token ${apiKey}` } });
-        const result = await poll.json() as { status: string; output?: string[]; error?: string };
-        if (result.status === 'succeeded' && result.output?.length) {
-          return { success: true, url: result.output[0], provider: 'replicate' };
-        }
-        if (result.status === 'failed') {
-          return { success: false, error: result.error || 'Generation failed', provider: 'replicate' };
-        }
-      }
-      return { success: false, error: 'Timeout waiting for image generation', provider: 'replicate' };
-    } catch (err) {
-      return { success: false, error: (err as Error).message, provider: 'replicate' };
-    }
-  }
-}

package/src/tools/integrations/calendar.ts

@@ -1,73 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const CalendarTool: MCPTool = {
-  name: 'calendar',
-  description: 'Google Calendar integration: create events, list events, check availability. Requires GOOGLE_CALENDAR_API_KEY or GOOGLE_ACCESS_TOKEN env var.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['create_event', 'list_events', 'check_availability'], description: 'Action' },
-      calendar_id: { type: 'string', description: 'Calendar ID (default: primary)' },
-      summary: { type: 'string', description: 'Event title' },
-      start: { type: 'string', description: 'Start time (ISO 8601)' },
-      end: { type: 'string', description: 'End time (ISO 8601)' },
-      description: { type: 'string', description: 'Event description' },
-      time_min: { type: 'string', description: 'Start of time range (ISO 8601)' },
-      time_max: { type: 'string', description: 'End of time range (ISO 8601)' },
-    },
-    required: ['action'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const token = process.env.GOOGLE_ACCESS_TOKEN;
-    if (!token) return { content: 'Error: GOOGLE_ACCESS_TOKEN required', isError: true };
-
-    const calId = encodeURIComponent(String(input.calendar_id ?? 'primary'));
-    const headers = { 'Authorization': `Bearer ${token}`, 'Content-Type': 'application/json' };
-    const action = String(input.action ?? '');
-
-    try {
-      if (action === 'create_event') {
-        if (!input.summary || !input.start || !input.end) return { content: 'Error: summary, start, end required', isError: true };
-        const res = await fetch(`https://www.googleapis.com/calendar/v3/calendars/${calId}/events`, {
-          method: 'POST', headers,
-          body: JSON.stringify({
-            summary: input.summary,
-            description: input.description ?? '',
-            start: { dateTime: input.start },
-            end: { dateTime: input.end },
-          }),
-        });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: `Event created: ${data.htmlLink ?? data.id}` };
-      }
-
-      if (action === 'list_events') {
-        const now = new Date().toISOString();
-        const timeMin = String(input.time_min ?? now);
-        const timeMax = input.time_max ? `&timeMax=${encodeURIComponent(String(input.time_max))}` : '';
-        const res = await fetch(`https://www.googleapis.com/calendar/v3/calendars/${calId}/events?timeMin=${encodeURIComponent(timeMin)}${timeMax}&maxResults=20&singleEvents=true&orderBy=startTime`, { headers });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
-      }
-
-      if (action === 'check_availability') {
-        if (!input.time_min || !input.time_max) return { content: 'Error: time_min, time_max required', isError: true };
-        const res = await fetch('https://www.googleapis.com/calendar/v3/freeBusy', {
-          method: 'POST', headers,
-          body: JSON.stringify({
-            timeMin: input.time_min,
-            timeMax: input.time_max,
-            items: [{ id: String(input.calendar_id ?? 'primary') }],
-          }),
-        });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
-      }
-
-      return { content: `Unknown action: ${action}`, isError: true };
-    } catch (err) {
-      return { content: `Calendar error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};

package/src/tools/integrations/code-exec.ts

@@ -1,39 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-import { execSync } from 'child_process';
-
-export const CodeExecutionTool: MCPTool = {
-  name: 'code-exec',
-  description: 'Execute JavaScript or Python code in a sandboxed subprocess.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      language: { type: 'string', enum: ['javascript', 'python'], description: 'Language to execute' },
-      code: { type: 'string', description: 'Code to execute' },
-      timeout: { type: 'number', description: 'Timeout in seconds (default: 10)' },
-    },
-    required: ['language', 'code'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const language = String(input.language ?? '');
-    const code = String(input.code ?? '');
-    if (!code) return { content: 'Error: code required', isError: true };
-
-    const timeout = Math.min(Number(input.timeout ?? 10), 30) * 1000;
-
-    try {
-      let result: string;
-      if (language === 'javascript') {
-        result = execSync(`node -e ${JSON.stringify(code)}`, { timeout, encoding: 'utf-8', maxBuffer: 1024 * 1024 });
-      } else if (language === 'python') {
-        result = execSync(`python -c ${JSON.stringify(code)}`, { timeout, encoding: 'utf-8', maxBuffer: 1024 * 1024 });
-      } else {
-        return { content: `Unsupported language: ${language}`, isError: true };
-      }
-      return { content: result.slice(0, 4000) || '(no output)' };
-    } catch (err) {
-      const msg = (err as Error & { stderr?: string }).stderr || (err as Error).message;
-      return { content: `Execution error: ${String(msg).slice(0, 2000)}`, isError: true };
-    }
-  },
-};

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

@@ -1,92 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 };
-    }
-  },
-};

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

@@ -1,76 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const GitHubTool: MCPTool = {
-  name: 'github',
-  description: 'Interact with GitHub API: create issues, list issues, create PRs, search code. Requires GITHUB_TOKEN env var.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['create_issue', 'list_issues', 'create_pr', 'search_code'], description: 'Action to perform' },
-      owner: { type: 'string', description: 'Repository owner' },
-      repo: { type: 'string', description: 'Repository name' },
-      title: { type: 'string', description: 'Issue/PR title' },
-      body: { type: 'string', description: 'Issue/PR body' },
-      head: { type: 'string', description: 'PR head branch' },
-      base: { type: 'string', description: 'PR base branch (default: main)' },
-      query: { type: 'string', description: 'Search query' },
-    },
-    required: ['action'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const token = process.env.GITHUB_TOKEN;
-    if (!token) return { content: 'Error: GITHUB_TOKEN required', isError: true };
-
-    const action = String(input.action ?? '');
-    const owner = String(input.owner ?? '');
-    const repo = String(input.repo ?? '');
-    const headers = {
-      'Authorization': `Bearer ${token}`,
-      'Accept': 'application/vnd.github+json',
-      'Content-Type': 'application/json',
-      'X-GitHub-Api-Version': '2022-11-28',
-    };
-
-    try {
-      if (action === 'create_issue') {
-        if (!owner || !repo || !input.title) return { content: 'Error: owner, repo, title required', isError: true };
-        const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues`, {
-          method: 'POST', headers,
-          body: JSON.stringify({ title: input.title, body: input.body ?? '' }),
-        });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: `Issue created: #${data.number} ${data.html_url}` };
-      }
-
-      if (action === 'list_issues') {
-        if (!owner || !repo) return { content: 'Error: owner, repo required', isError: true };
-        const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues?per_page=20`, { headers });
-        const data = await res.json() as Array<Record<string, unknown>>;
-        const summary = Array.isArray(data) ? data.map((i) => `#${i.number} ${i.title}`).join('\n') : JSON.stringify(data);
-        return { content: summary };
-      }
-
-      if (action === 'create_pr') {
-        if (!owner || !repo || !input.title || !input.head) return { content: 'Error: owner, repo, title, head required', isError: true };
-        const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/pulls`, {
-          method: 'POST', headers,
-          body: JSON.stringify({ title: input.title, body: input.body ?? '', head: input.head, base: input.base ?? 'main' }),
-        });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: `PR created: #${data.number} ${data.html_url}` };
-      }
-
-      if (action === 'search_code') {
-        if (!input.query) return { content: 'Error: query required', isError: true };
-        const res = await fetch(`https://api.github.com/search/code?q=${encodeURIComponent(String(input.query))}`, { headers });
-        const data = await res.json() as Record<string, unknown>;
-        return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
-      }
-
-      return { content: `Unknown action: ${action}`, isError: true };
-    } catch (err) {
-      return { content: `GitHub error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};

package/src/tools/integrations/image-gen.ts

@@ -1,56 +0,0 @@
-import type { MCPTool, MCPToolResult } from '../mcp';
-
-export const ImageGenerationTool: MCPTool = {
-  name: 'image-gen',
-  description: 'Generate images via DALL-E or StableDiffusion API. Requires OPENAI_API_KEY or SD_API_URL env var.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      prompt: { type: 'string', description: 'Image generation prompt' },
-      provider: { type: 'string', enum: ['dalle', 'stable-diffusion'], description: 'Provider (auto-detects)' },
-      size: { type: 'string', description: 'Image size (default: 1024x1024)' },
-      model: { type: 'string', description: 'Model name (default: dall-e-3)' },
-    },
-    required: ['prompt'],
-  },
-
-  async execute(input: Record<string, unknown>): Promise<MCPToolResult> {
-    const prompt = String(input.prompt ?? '');
-    if (!prompt) return { content: 'Error: prompt required', isError: true };
-
-    const provider = String(input.provider ?? '');
-
-    try {
-      if (provider === 'stable-diffusion' || process.env.SD_API_URL) {
-        const url = process.env.SD_API_URL;
-        if (!url) return { content: 'Error: SD_API_URL required', isError: true };
-        const res = await fetch(`${url}/sdapi/v1/txt2img`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ prompt, width: 1024, height: 1024 }),
-        });
-        const data = await res.json() as { images?: string[] };
-        return { content: `Generated ${data.images?.length ?? 0} image(s)`, metadata: { images: data.images } };
-      }
-
-      // Default: DALL-E
-      const apiKey = process.env.OPENAI_API_KEY;
-      if (!apiKey) return { content: 'Error: OPENAI_API_KEY or SD_API_URL required', isError: true };
-      const res = await fetch('https://api.openai.com/v1/images/generations', {
-        method: 'POST',
-        headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          model: String(input.model ?? 'dall-e-3'),
-          prompt,
-          size: String(input.size ?? '1024x1024'),
-          n: 1,
-        }),
-      });
-      const data = await res.json() as { data?: Array<{ url: string }> };
-      const url = data.data?.[0]?.url;
-      return { content: url ? `Image generated: ${url}` : 'Error generating image', metadata: { url } };
-    } catch (err) {
-      return { content: `Image gen error: ${(err as Error).message}`, isError: true };
-    }
-  },
-};