@exreve/exk 1.0.60 → 1.0.62

package/dist/cli/moduleMcpServer.js

@@ -1,326 +1,65 @@
 /**
- * Module MCP Server
+ * Module MCP Server (Claude Agent SDK)
  *
- * Provides built-in tools like analyze_image for vision capabilities
- * and send_file for displaying files to the user in chat.
+ * Thin wrapper that creates Claude Agent SDK MCP tools using the shared
+ * tool executors from sharedTools.ts. This ensures all backends share the
+ * same tool logic.
  */
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import sharp from 'sharp';
-import { getOpenrouterApiKey, getApiUrl } from './agentSession.js';
-const MAX_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
-/** Comprehensive MIME type map for file extension detection */
-const MIME_MAP = {
-    // Images
-    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
-    gif: 'image/gif', webp: 'image/webp', bmp: 'image/bmp',
-    svg: 'image/svg+xml', ico: 'image/x-icon', tiff: 'image/tiff', tif: 'image/tiff',
-    avif: 'image/avif',
-    // Audio
-    mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg',
-    m4a: 'audio/mp4', flac: 'audio/flac', aac: 'audio/aac',
-    wma: 'audio/x-ms-wma', opus: 'audio/opus',
-    // Video
-    mp4: 'video/mp4', webm: 'video/webm', mkv: 'video/x-matroska',
-    avi: 'video/x-msvideo', mov: 'video/quicktime', wmv: 'video/x-ms-wmv',
-    m4v: 'video/mp4', '3gp': 'video/3gpp',
-    // Documents
-    pdf: 'application/pdf',
-    // Text / Code
-    txt: 'text/plain', md: 'text/markdown', csv: 'text/csv',
-    json: 'application/json', xml: 'text/xml', yaml: 'text/yaml', yml: 'text/yaml',
-    toml: 'text/plain', html: 'text/html', htm: 'text/html',
-    css: 'text/css', scss: 'text/x-scss', less: 'text/x-less',
-    js: 'text/javascript', mjs: 'text/javascript', cjs: 'text/javascript',
-    ts: 'text/typescript', tsx: 'text/typescript',
-    jsx: 'text/javascript', py: 'text/x-python', rs: 'text/x-rust',
-    go: 'text/x-go', java: 'text/x-java', c: 'text/x-c', cpp: 'text/x-c++',
-    h: 'text/x-c', hpp: 'text/x-c++', rb: 'text/x-ruby', php: 'text/x-php',
-    sh: 'text/x-shellscript', bash: 'text/x-shellscript', zsh: 'text/x-shellscript',
-    sql: 'text/x-sql', graphql: 'text/graphql', vue: 'text/x-vue',
-    svelte: 'text/x-svelte', dart: 'text/x-dart', swift: 'text/x-swift',
-    kt: 'text/x-kotlin', scala: 'text/x-scala', lua: 'text/x-lua',
-    r: 'text/x-r', dockerfile: 'text/x-dockerfile',
-};
+import { executeAnalyzeImage, executeSendFile, executeBrowserQuery } from './sharedTools.js';
 /**
- * Get MIME type from file extension
+ * Build the shared config from MCP server config.
  */
-function getMimeType(filePath) {
-    const ext = path.extname(filePath).toLowerCase().replace('.', '');
-    return MIME_MAP[ext] || 'application/octet-stream';
-}
-const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'tiff', 'tif', 'avif']);
-const MAX_IMAGE_DIMENSION = 2048; // max width or height in pixels
-const MAX_IMAGE_BYTES = 2 * 1024 * 1024; // 2 MB target after compression
-function isImageFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase().replace('.', '');
-    return IMAGE_EXTENSIONS.has(ext);
-}
-/**
- * Compress and resize an image buffer using sharp.
- * - Resizes so neither dimension exceeds MAX_IMAGE_DIMENSION (fit: inside, no upscale)
- * - Converts to JPEG quality 80 (or WebP for non-photo sources)
- * - If already small enough, returns the original buffer unchanged
- */
-async function compressImage(buf) {
-    const metadata = await sharp(buf).metadata();
-    const { width = 0, height = 0, size = 0 } = metadata;
-    // If already under limits, keep as-is
-    const needsResize = width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION;
-    const needsCompress = (size || buf.length) > MAX_IMAGE_BYTES;
-    if (!needsResize && !needsCompress) {
-        // Keep original format
-        const fmt = metadata.format || 'jpeg';
-        const mime = fmt === 'png' ? 'image/png' : fmt === 'webp' ? 'image/webp' : 'image/jpeg';
-        return { data: buf, mime };
-    }
-    let pipeline = sharp(buf)
-        .resize(MAX_IMAGE_DIMENSION, MAX_IMAGE_DIMENSION, { fit: 'inside', withoutEnlargement: true });
-    // Convert to JPEG for best compression on photos; use WebP for PNGs with alpha
-    const hasAlpha = metadata.hasAlpha;
-    if (hasAlpha) {
-        pipeline = pipeline.webp({ quality: 80 });
-        return { data: await pipeline.toBuffer(), mime: 'image/webp' };
-    }
-    pipeline = pipeline.jpeg({ quality: 80 });
-    return { data: await pipeline.toBuffer(), mime: 'image/jpeg' };
-}
-/**
- * Convert a file to a data URI (base64 encoded).
- * Images are compressed and resized before encoding.
- */
-async function fileToDataUri(filePath) {
-    try {
-        const buf = fs.readFileSync(filePath);
-        if (isImageFile(filePath)) {
-            const { data, mime } = await compressImage(buf);
-            return `data:${mime};base64,${data.toString('base64')}`;
-        }
-        const mime = getMimeType(filePath);
-        return `data:${mime};base64,${buf.toString('base64')}`;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Create the analyze_image tool for vision capabilities via OpenRouter
- */
-function createAnalyzeImageTool(attachmentDir) {
-    const workDir = attachmentDir || os.tmpdir();
-    return tool('analyze_image', 'Analyze one or more image files using a vision model. Pass the path to an image file and a question. Returns a detailed text answer about the image content.', {
-        image_path: z.string().describe('Path to the image file to analyze (can be relative to working directory, e.g. "attachments/photo.jpg")'),
-        question: z.string().describe('Question or instruction about the image. Be specific about what you want to know.'),
-    }, async (args) => {
-        const apiKey = getOpenrouterApiKey();
-        if (!apiKey) {
-            return { content: [{ type: 'text', text: 'Error: OPENROUTER_API_KEY not configured.' }], isError: true };
-        }
-        try {
-            // Resolve relative paths against the attachment dir
-            const imagePath = path.resolve(workDir, args.image_path);
-            if (!fs.existsSync(imagePath)) {
-                return { content: [{ type: 'text', text: `Error: Image file not found: ${args.image_path}` }], isError: true };
-            }
-            const dataUri = await fileToDataUri(imagePath);
-            if (!dataUri) {
-                return { content: [{ type: 'text', text: `Error: Could not read image file: ${args.image_path}` }], isError: true };
-            }
-            const OPENROUTER_ENDPOINT = 'https://openrouter.ai/api/v1/chat/completions';
-            const OPENROUTER_MODEL = 'qwen/qwen3.5-27b';
-            const res = await fetch(OPENROUTER_ENDPOINT, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${apiKey}` },
-                body: JSON.stringify({
-                    model: OPENROUTER_MODEL,
-                    messages: [{ role: 'user', content: [
-                                { type: 'text', text: args.question },
-                                { type: 'image_url', image_url: { url: dataUri } },
-                            ] }],
-                }),
-                signal: AbortSignal.timeout(60_000),
-            });
-            const raw = await res.text();
-            if (!res.ok) {
-                return { content: [{ type: 'text', text: `Error from vision API (${res.status}): ${raw.slice(0, 500)}` }], isError: true };
-            }
-            const parsed = JSON.parse(raw);
-            return { content: [{ type: 'text', text: parsed.choices?.[0]?.message?.content || raw }] };
-        }
-        catch (error) {
-            return { content: [{ type: 'text', text: `Error analyzing image: ${error.message}` }], isError: true };
-        }
-    });
-}
-/**
- * Create the send_file tool for displaying files to the user in chat.
- * Supports images, audio, video, PDFs, code, and other files.
- */
-function createSendFileTool(attachmentDir) {
-    const workDir = attachmentDir || os.tmpdir();
-    return tool('send_file', 'Send a file to the user for display in chat. Supports images (shown inline), audio/video (with player), PDFs, code files (syntax highlighted), and other files (download link). Use file_path for local files or data for base64-encoded content.', {
-        file_path: z.string().optional().describe('Path to a local file on this device (absolute or relative to project directory)'),
-        data: z.string().optional().describe('Base64-encoded file content (without data: prefix)'),
-        mime_type: z.string().optional().describe('MIME type of the file (required when using data, auto-detected from file_path)'),
-        filename: z.string().optional().describe('Display name for the file (auto-detected from file_path)'),
-    }, async (args) => {
-        try {
-            let dataUri;
-            let mimeType;
-            let fileName;
-            let fileSize;
-            if (args.file_path) {
-                // Read from local file
-                const filePath = path.resolve(workDir, args.file_path);
-                if (!fs.existsSync(filePath)) {
-                    return { content: [{ type: 'text', text: `Error: File not found: ${args.file_path}` }], isError: true };
-                }
-                const stat = fs.statSync(filePath);
-                fileSize = stat.size;
-                if (fileSize > MAX_FILE_SIZE) {
-                    return { content: [{ type: 'text', text: `Error: File too large (${(fileSize / (1024 * 1024)).toFixed(1)} MB). Maximum size is ${MAX_FILE_SIZE / (1024 * 1024)} MB.` }], isError: true };
-                }
-                const buf = fs.readFileSync(filePath);
-                mimeType = args.mime_type || getMimeType(filePath);
-                fileName = args.filename || path.basename(filePath);
-                dataUri = `data:${mimeType};base64,${buf.toString('base64')}`;
-            }
-            else if (args.data) {
-                // Use provided base64 data
-                mimeType = args.mime_type || 'application/octet-stream';
-                fileName = args.filename || 'file';
-                const rawBase64 = args.data.replace(/^data:[^;]+;base64,/, '');
-                fileSize = Math.floor(rawBase64.length * 0.75);
-                if (fileSize > MAX_FILE_SIZE) {
-                    return { content: [{ type: 'text', text: `Error: Data too large (~${(fileSize / (1024 * 1024)).toFixed(1)} MB). Maximum size is ${MAX_FILE_SIZE / (1024 * 1024)} MB.` }], isError: true };
-                }
-                dataUri = `data:${mimeType};base64,${rawBase64}`;
-            }
-            else {
-                return { content: [{ type: 'text', text: 'Error: Either file_path or data must be provided.' }], isError: true };
-            }
-            // Return structured result that the frontend will detect
-            const result = JSON.stringify({
-                _type: 'send_file',
-                data: dataUri,
-                mime_type: mimeType,
-                filename: fileName,
-                size: fileSize,
-            });
-            return { content: [{ type: 'text', text: result }] };
-        }
-        catch (error) {
-            return { content: [{ type: 'text', text: `Error sending file: ${error.message}` }], isError: true };
-        }
-    });
-}
-/**
- * Create the browser_query tool for web automation via the backend.
- * The agent can fire multiple queries concurrently — screenshots stream
- * to the frontend independently while the tool blocks until completion.
- */
-function createBrowserQueryTool(config) {
-    return tool('browser_query', 'Launch a headless browser to automate web tasks such as searching, reading pages, filling forms, extracting data, etc. ' +
-        'Returns the answer, optionally structured data, and step count. ' +
-        'IMPORTANT: This tool is slow (30-120 seconds per query). You CAN and SHOULD call browser_query multiple times concurrently ' +
-        '— the browser handles each in a separate session. While waiting for results, continue with other work (file edits, analysis, etc.). ' +
-        'Do NOT wait for one browser query to finish before starting another if you need multiple lookups.', {
-        query: z.string().describe('Natural language task for the browser agent (e.g. "Go to google.com and search for the price of Bitcoin")'),
-        schema: z.string().optional().describe('JSON schema for structured output, as a JSON string (e.g. \'{"type":"object","properties":{"price":{"type":"number"}}}\')'),
-        maxSteps: z.number().optional().describe('Max automation steps, default 20. Use lower values for simple tasks.'),
-        country: z.string().optional().describe('2-letter country code for proxy and locale (e.g. "US", "GB", "DE"). Uses direct connection if omitted.'),
-        mobile: z.boolean().optional().describe('If true, use mobile viewport (390x844 — iPhone 14 dimensions) instead of desktop.'),
-    }, async (args) => {
-        const apiUrl = getApiUrl();
-        // Read device ID for CLI auth
-        let deviceId = '';
-        try {
-            const deviceIdPath = path.join(os.homedir(), '.talk-to-code', 'device-id.json');
-            const data = fs.readFileSync(deviceIdPath, 'utf-8');
-            deviceId = JSON.parse(data).deviceId || '';
-        }
-        catch {
-            // No device ID file — will still work if backend has relaxed auth
-        }
-        try {
-            const body = {
-                query: args.query,
-                maxSteps: args.maxSteps || 20,
-            };
-            if (args.schema) {
-                try {
-                    body.schema = JSON.parse(args.schema);
-                }
-                catch {
-                    body.schema = args.schema;
-                }
-            }
-            if (args.country)
-                body.country = args.country;
-            if (args.mobile)
-                body.mobile = args.mobile;
-            if (config.sessionId)
-                body.sessionId = config.sessionId;
-            if (config.promptId)
-                body.promptId = config.promptId;
-            const res = await fetch(`${apiUrl}/api/browser/query`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...(deviceId ? { 'X-Device-ID': deviceId } : {}),
-                },
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(10 * 60 * 1000), // 10 min timeout
-            });
-            const raw = await res.text();
-            if (!res.ok) {
-                return {
-                    content: [{ type: 'text', text: `Error from browser agent (${res.status}): ${raw.slice(0, 500)}` }],
-                    isError: true,
-                };
-            }
-            const result = JSON.parse(raw);
-            // Format a nice summary for the agent
-            const summary = [
-                `Browser query completed in ${result.steps} steps.`,
-                result.answer ? `\n\n**Answer:** ${result.answer}` : '',
-                result.data ? `\n\n**Structured Data:**\n\`\`\`json\n${JSON.stringify(result.data, null, 2)}\n\`\`\`` : '',
-                result.logs?.length ? `\n\n**Log:**\n${result.logs.slice(-5).join('\n')}` : '',
-            ].join('');
-            return { content: [{ type: 'text', text: summary }] };
-        }
-        catch (error) {
-            if (error.name === 'TimeoutError') {
-                return {
-                    content: [{ type: 'text', text: 'Browser query timed out after 10 minutes. Try reducing maxSteps or simplifying the query.' }],
-                    isError: true,
-                };
-            }
-            return {
-                content: [{ type: 'text', text: `Error running browser query: ${error.message}` }],
-                isError: true,
-            };
-        }
-    });
+function toSharedConfig(config) {
+    return {
+        attachmentDir: config.attachmentDir,
+        sessionId: config.sessionId,
+        promptId: config.promptId,
+    };
 }
 /**
- * Create the MCP server with built-in tools
+ * Create the MCP server with built-in tools.
  */
 export function createModuleMcpServer(config) {
-    const tools = [];
-    // Always add analyze_image tool (uses OpenRouter key from ai-config via backend)
-    tools.push(createAnalyzeImageTool(config.attachmentDir));
-    // Add send_file tool for displaying files to the user in chat
-    tools.push(createSendFileTool(config.attachmentDir));
-    // Add browser_query tool for web automation
-    tools.push(createBrowserQueryTool(config));
-    const server = createSdkMcpServer({
+    const sharedConfig = toSharedConfig(config);
+    const tools = [
+        tool('analyze_image', 'Analyze one or more image files using a vision model. Pass the path to an image file and a question. Returns a detailed text answer about the image content.', {
+            image_path: z.string().describe('Path to the image file to analyze (can be relative to working directory, e.g. "attachments/photo.jpg")'),
+            question: z.string().describe('Question or instruction about the image. Be specific about what you want to know.'),
+        }, async (args) => executeAnalyzeImage({ image_path: args.image_path, question: args.question }, sharedConfig)),
+        tool('send_file', 'Send a file to the user for display in chat. Supports images (shown inline), audio/video (with player), PDFs, code files (syntax highlighted), and other files (download link). Use file_path for local files or data for base64-encoded content.', {
+            file_path: z.string().optional().describe('Path to a local file on this device (absolute or relative to project directory)'),
+            data: z.string().optional().describe('Base64-encoded file content (without data: prefix)'),
+            mime_type: z.string().optional().describe('MIME type of the file (required when using data, auto-detected from file_path)'),
+            filename: z.string().optional().describe('Display name for the file (auto-detected from file_path)'),
+        }, async (args) => executeSendFile({
+            file_path: args.file_path,
+            data: args.data,
+            mime_type: args.mime_type,
+            filename: args.filename,
+        }, sharedConfig)),
+        tool('browser_query', 'Launch a headless browser to automate web tasks such as searching, reading pages, filling forms, extracting data, etc. ' +
+            'Returns the answer, optionally structured data, and step count. ' +
+            'IMPORTANT: This tool is slow (30-120 seconds per query). You CAN and SHOULD call browser_query multiple times concurrently ' +
+            '— the browser handles each in a separate session. While waiting for results, continue with other work (file edits, analysis, etc.). ' +
+            'Do NOT wait for one browser query to finish before starting another if you need multiple lookups.', {
+            query: z.string().describe('Natural language task for the browser agent (e.g. "Go to google.com and search for the price of Bitcoin")'),
+            schema: z.string().optional().describe('JSON schema for structured output, as a JSON string (e.g. \'{"type":"object","properties":{"price":{"type":"number"}}}\')'),
+            maxSteps: z.number().optional().describe('Max automation steps, default 20. Use lower values for simple tasks.'),
+            country: z.string().optional().describe('2-letter country code for proxy and locale (e.g. "US", "GB", "DE"). Uses direct connection if omitted.'),
+            mobile: z.boolean().optional().describe('If true, use mobile viewport (390x844 — iPhone 14 dimensions) instead of desktop.'),
+        }, async (args) => executeBrowserQuery({
+            query: args.query,
+            schema: args.schema,
+            maxSteps: args.maxSteps,
+            country: args.country,
+            mobile: args.mobile,
+        }, sharedConfig)),
+    ];
+    return createSdkMcpServer({
         name: 'claude-voice-modules',
         version: '1.0.0',
-        tools
+        tools,
     });
-    return server;
 }