opc-agent 2.1.0 → 3.0.0

package/dist/tools/integrations/calendar.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const CalendarTool: MCPTool;
+//# sourceMappingURL=calendar.d.ts.map

package/dist/tools/integrations/calendar.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarTool = void 0;
+exports.CalendarTool = {
+    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) {
+        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();
+                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();
+                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();
+                return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
+            }
+            return { content: `Unknown action: ${action}`, isError: true };
+        }
+        catch (err) {
+            return { content: `Calendar error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=calendar.js.map

package/dist/tools/integrations/code-exec.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const CodeExecutionTool: MCPTool;
+//# sourceMappingURL=code-exec.d.ts.map

package/dist/tools/integrations/code-exec.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeExecutionTool = void 0;
+const child_process_1 = require("child_process");
+exports.CodeExecutionTool = {
+    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) {
+        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;
+            if (language === 'javascript') {
+                result = (0, child_process_1.execSync)(`node -e ${JSON.stringify(code)}`, { timeout, encoding: 'utf-8', maxBuffer: 1024 * 1024 });
+            }
+            else if (language === 'python') {
+                result = (0, child_process_1.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.stderr || err.message;
+            return { content: `Execution error: ${String(msg).slice(0, 2000)}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=code-exec.js.map

package/dist/tools/integrations/csv-analyzer.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const CSVAnalyzerTool: MCPTool;
+//# sourceMappingURL=csv-analyzer.d.ts.map

package/dist/tools/integrations/csv-analyzer.js

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSVAnalyzerTool = void 0;
+const fs = __importStar(require("fs"));
+exports.CSVAnalyzerTool = {
+    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) {
+        try {
+            let csvText;
+            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 = {};
+                    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;
+                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.message}`, isError: true };
+        }
+    },
+};
+function parseCsvLine(line) {
+    const result = [];
+    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;
+}
+//# sourceMappingURL=csv-analyzer.js.map

package/dist/tools/integrations/database.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const DatabaseTool: MCPTool;
+//# sourceMappingURL=database.d.ts.map

package/dist/tools/integrations/database.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseTool = void 0;
+const child_process_1 = require("child_process");
+exports.DatabaseTool = {
+    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) {
+        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 = (0, child_process_1.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.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=database.js.map

package/dist/tools/integrations/email-send.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const EmailSendTool: MCPTool;
+//# sourceMappingURL=email-send.d.ts.map

package/dist/tools/integrations/email-send.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmailSendTool = void 0;
+const net = __importStar(require("net"));
+const tls = __importStar(require("tls"));
+exports.EmailSendTool = {
+    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) {
+        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.message}`, isError: true };
+        }
+    },
+};
+function sendSmtp(host, port, user, pass, from, to, subject, body) {
+    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); });
+    });
+}
+//# sourceMappingURL=email-send.js.map

package/dist/tools/integrations/git-tool.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const GitTool: MCPTool;
+//# sourceMappingURL=git-tool.d.ts.map

package/dist/tools/integrations/git-tool.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitTool = void 0;
+const child_process_1 = require("child_process");
+exports.GitTool = {
+    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) {
+        const action = String(input.action ?? '');
+        const cwd = String(input.cwd ?? process.cwd());
+        const args = String(input.args ?? '');
+        try {
+            let cmd;
+            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 = (0, child_process_1.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.message.slice(0, 1000)}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=git-tool.js.map

package/dist/tools/integrations/github-tool.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const GitHubTool: MCPTool;
+//# sourceMappingURL=github-tool.d.ts.map

package/dist/tools/integrations/github-tool.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHubTool = void 0;
+exports.GitHubTool = {
+    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) {
+        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();
+                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();
+                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();
+                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();
+                return { content: JSON.stringify(data, null, 2).slice(0, 4000) };
+            }
+            return { content: `Unknown action: ${action}`, isError: true };
+        }
+        catch (err) {
+            return { content: `GitHub error: ${err.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=github-tool.js.map

package/dist/tools/integrations/image-gen.d.ts

@@ -0,0 +1,3 @@
+import type { MCPTool } from '../mcp';
+export declare const ImageGenerationTool: MCPTool;
+//# sourceMappingURL=image-gen.d.ts.map

package/dist/tools/integrations/image-gen.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageGenerationTool = void 0;
+exports.ImageGenerationTool = {
+    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) {
+        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();
+                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();
+            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.message}`, isError: true };
+        }
+    },
+};
+//# sourceMappingURL=image-gen.js.map