@exreve/exk 1.0.38 → 1.0.39

package/dist/agentSession.js

@@ -101,9 +101,17 @@ function extractToolName(toolResult) {
     }
     if (toolResult.stdout !== undefined || toolResult.stderr !== undefined)
         return 'Bash';
-    // SDK 0.2.x: content-only results from nested tool calls (no stdout/stderr wrapper)
-    if (toolResult.content && typeof toolResult.content === 'string' && toolResult.type === 'text')
+    // send_file tool: content is JSON with _type marker — detect before Bash fallback
+    if (toolResult.content && typeof toolResult.content === 'string' && toolResult.type === 'text') {
+        try {
+            const parsed = JSON.parse(toolResult.content);
+            if (parsed._type === 'send_file')
+                return 'send_file';
+        }
+        catch { /* not JSON, fall through */ }
+        // SDK 0.2.x: content-only results from nested tool calls (no stdout/stderr wrapper)
         return 'Bash';
+    }
     return 'unknown';
 }
 // Look up tool name from the most recent assistant message's tool_use blocks by tool_use_id

package/dist/moduleMcpServer.js

@@ -1,7 +1,8 @@
 /**
  * Module MCP Server
  *
- * Provides built-in tools like analyze_image for vision capabilities.
+ * 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';
@@ -9,19 +10,54 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { getOpenrouterApiKey } 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',
+};
 /**
- * Convert a file to a data URI for vision API consumption
+ * 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 ext = path.extname(filePath).toLowerCase().replace('.', '');
-        const mimeMap = {
-            png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
-            gif: 'image/gif', webp: 'image/webp', bmp: 'image/bmp',
-            svg: 'image/svg+xml',
-        };
-        const mime = mimeMap[ext] || 'application/octet-stream';
+        const mime = getMimeType(filePath);
         return `data:${mime};base64,${buf.toString('base64')}`;
     }
     catch {
@@ -78,12 +114,76 @@ function createAnalyzeImageTool(attachmentDir) {
     });
 }
 /**
- * Create the MCP server with built-in tools (always includes analyze_image)
+ * 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 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));
     const server = createSdkMcpServer({
         name: 'claude-voice-modules',
         version: '1.0.0',

package/dist/transferService.js

@@ -71,6 +71,8 @@ export function startSending(socket, transfer, foreground) {
             const msg = data.toString().trim();
             if (msg)
                 log(`tar: ${msg}`);
+            // Count lines in tar stderr as approximate file count
+            fileCount += msg.split('\n').length;
         });
         tar.on('error', (err) => {
             sendError(`tar process error: ${err.message}`);
@@ -81,16 +83,6 @@ export function startSending(socket, transfer, foreground) {
                 return;
             }
             log(`Packing complete. Final size: ${formatBytes(bytesTransferred)}`);
-            const sha256 = hash.digest('hex');
-            const duration = Date.now() - startTime;
-            // Notify backend that upload is done
-            socket.emit('transfer:uploaded', {
-                transferId,
-                totalBytes: bytesTransferred,
-                sha256,
-                fileCount,
-            });
-            log(`Upload complete: ${formatBytes(bytesTransferred)} in ${(duration / 1000).toFixed(1)}s (sha256: ${sha256.slice(0, 12)}...)`);
         });
         // Stream tar output through hash, then HTTP POST
         const uploadUrl = `${apiUrl}/transfer/${transferId}/upload`;
@@ -123,7 +115,18 @@ export function startSending(socket, transfer, foreground) {
             if (!res.ok) {
                 const text = await res.text();
                 sendError(`Upload failed: HTTP ${res.status} ${text}`);
+                return;
             }
+            const sha256 = hash.digest('hex');
+            const duration = Date.now() - startTime;
+            // Notify backend that upload is done (only after HTTP confirms success)
+            socket.emit('transfer:uploaded', {
+                transferId,
+                totalBytes: bytesTransferred,
+                sha256,
+                fileCount,
+            });
+            log(`Upload complete: ${formatBytes(bytesTransferred)} in ${(duration / 1000).toFixed(1)}s (sha256: ${sha256.slice(0, 12)}...)`);
         }).catch((err) => {
             sendError(`Upload network error: ${err.message}`);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {