@exreve/exk 1.0.54 → 1.0.56

package/dist/moduleMcpServer.js

@@ -1,284 +0,0 @@
-/**
- * Module MCP Server
- *
- * Provides built-in tools like analyze_image for vision capabilities
- * and send_file for displaying files to the user in chat.
- */
-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 { 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',
-};
-/**
- * Get MIME type from file extension
- */
-function getMimeType(filePath) {
-    const ext = path.extname(filePath).toLowerCase().replace('.', '');
-    return MIME_MAP[ext] || 'application/octet-stream';
-}
-/**
- * Convert a file to a data URI (base64 encoded)
- */
-function fileToDataUri(filePath) {
-    try {
-        const buf = fs.readFileSync(filePath);
-        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 = 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,
-            };
-        }
-    });
-}
-/**
- * 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({
-        name: 'claude-voice-modules',
-        version: '1.0.0',
-        tools
-    });
-    return server;
-}

package/dist/openaiAdapter.js

@@ -1,181 +0,0 @@
-/**
- * OpenAI Adapter - Spawns an anthropic-proxy that translates Anthropic Messages API
- * to OpenAI Chat Completions API. This allows Claude Agent SDK to talk to any
- * OpenAI-compatible endpoint (Ollama, vLLM, local LLMs, etc.)
- *
- * Usage:
- *   import { startOpenAIAdapter, isLocalModel } from './openaiAdapter.js'
- *
- *   if (isLocalModel(sessionModel)) {
- *     const proxyUrl = await startOpenAIAdapter({
- *       targetBaseUrl: 'http://192.168.1.101:3000',
- *       model: 'qwen3.5-27b',
- *     })
- *     // point ANTHROPIC_BASE_URL to proxyUrl
- *   }
- */
-import { spawn } from 'child_process';
-import { createRequire } from 'module';
-const VALID_LOCAL_PREFIXES = ['ollama:', 'openai:', 'local:'];
-/** Check if a model ID refers to a local/OpenAI model that needs the adapter */
-export function isLocalModel(model) {
-    return VALID_LOCAL_PREFIXES.some(p => model.startsWith(p));
-}
-/** Extract the actual model name by stripping the prefix (e.g. "ollama:qwen3:4b" -> "qwen3:4b") */
-export function unwrapModelName(model) {
-    for (const prefix of VALID_LOCAL_PREFIXES) {
-        if (model.startsWith(prefix)) {
-            return model.slice(prefix.length);
-        }
-    }
-    return model;
-}
-// Track running proxies by target+model to reuse them
-const runningProxies = new Map();
-function getProxyKey(config) {
-    return `${config.targetBaseUrl}::${config.model}`;
-}
-/** Find a free port in the given range */
-async function findFreePort(start, end) {
-    const net = await import('net');
-    return new Promise((resolve, reject) => {
-        function tryPort(port) {
-            if (port > end) {
-                reject(new Error(`No free port found in range ${start}-${end}`));
-                return;
-            }
-            const server = net.createServer();
-            server.listen(port, '127.0.0.1', () => {
-                const addr = server.address();
-                server.close(() => resolve(typeof addr === 'object' && addr ? addr.port : port));
-            });
-            server.on('error', () => tryPort(port + 1));
-        }
-        tryPort(start);
-    });
-}
-/**
- * Start an anthropic-proxy instance for the given config.
- * Returns the local proxy URL (e.g. http://127.0.0.1:8321) that speaks Anthropic Messages API.
- *
- * Proxies are reused - calling this twice with the same target+model returns the same URL.
- */
-export async function startOpenAIAdapter(config) {
-    const key = getProxyKey(config);
-    // Reuse existing proxy if running
-    const existing = runningProxies.get(key);
-    if (existing && !existing.process.killed) {
-        return existing.url;
-    }
-    const port = config.port || await findFreePort(8321, 8340);
-    // Resolve anthropic-proxy entry point
-    const req = typeof globalThis.require === 'function'
-        ? globalThis.require
-        : createRequire(import.meta.url);
-    let proxyPath;
-    try {
-        const pkgPath = req.resolve('anthropic-proxy/package.json');
-        proxyPath = pkgPath.replace(/package\.json$/, 'index.js');
-    }
-    catch {
-        throw new Error('anthropic-proxy package not found. Run: npm install anthropic-proxy');
-    }
-    const env = {
-        ...process.env,
-        ANTHROPIC_PROXY_BASE_URL: config.targetBaseUrl,
-        PORT: String(port),
-        REASONING_MODEL: config.model,
-        COMPLETION_MODEL: config.model,
-        // Suppress fastify logger noise
-        FASTIFY_LOG_LEVEL: 'error',
-    };
-    if (config.apiKey) {
-        env.OPENAI_API_KEY = config.apiKey;
-    }
-    const child = spawn('node', [proxyPath], {
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        windowsHide: true,
-    });
-    // Suppress stdout/stderr but log errors
-    let stderrBuf = '';
-    child.stderr?.on('data', (data) => {
-        stderrBuf += data.toString();
-        // Only log actual errors, not fastify startup messages
-        if (stderrBuf.toLowerCase().includes('error') && !stderrBuf.includes('fastify')) {
-            console.error(`[openaiAdapter] Proxy stderr: ${stderrBuf}`);
-        }
-        stderrBuf = '';
-    });
-    child.on('exit', (code) => {
-        runningProxies.delete(key);
-        if (code && code !== 0) {
-            console.error(`[openaiAdapter] Proxy exited with code ${code}`);
-        }
-    });
-    const url = `http://127.0.0.1:${port}`;
-    // Wait for proxy to be ready (poll /v1/messages with a simple request)
-    const maxAttempts = 20;
-    for (let i = 0; i < maxAttempts; i++) {
-        await new Promise(r => setTimeout(r, 100));
-        try {
-            const resp = await fetch(`${url}/v1/messages`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({
-                    model: config.model,
-                    max_tokens: 1,
-                    messages: [{ role: 'user', content: 'ping' }],
-                }),
-            });
-            if (resp.ok || resp.status === 400 || resp.status === 422) {
-                // 400/422 means the proxy is up but the request was invalid - that's fine for a health check
-                runningProxies.set(key, { process: child, port, url });
-                console.log(`[openaiAdapter] Proxy ready at ${url} -> ${config.targetBaseUrl} (model: ${config.model})`);
-                return url;
-            }
-        }
-        catch {
-            // Not ready yet, retry
-        }
-    }
-    // If health check failed but process is still running, assume it's ready
-    if (!child.killed) {
-        runningProxies.set(key, { process: child, port, url });
-        console.log(`[openaiAdapter] Proxy started at ${url} (health check timed out, assuming ready)`);
-        return url;
-    }
-    throw new Error(`Failed to start anthropic-proxy for ${config.targetBaseUrl}`);
-}
-/**
- * Get the adapter configuration for a local model.
- * Reads from ~/.talk-to-code/openai-adapters.json or falls back to defaults.
- */
-export function getAdapterConfig(model) {
-    // Strip prefix to get the raw model name
-    const rawModel = unwrapModelName(model);
-    // Determine provider from prefix
-    if (model.startsWith('ollama:')) {
-        return { targetBaseUrl: 'http://127.0.0.1:11434' };
-    }
-    // For 'openai:' and 'local:' prefix, read from config file
-    try {
-        const req = typeof globalThis.require === 'function'
-            ? globalThis.require
-            : createRequire(import.meta.url);
-        const fs = req('fs');
-        const path = req('path');
-        const os = req('os');
-        const configPath = path.join(os.homedir(), '.talk-to-code', 'openai-adapters.json');
-        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-        // Config format: { "default": { "baseUrl": "...", "apiKey": "..." }, ... }
-        const entry = config.default || config[rawModel];
-        if (entry?.baseUrl) {
-            return { targetBaseUrl: entry.baseUrl, apiKey: entry.apiKey };
-        }
-    }
-    catch (e) {
-        console.error('[openaiAdapter] Failed to read adapter config:', e);
-    }
-    return null;
-}