@exreve/exk 1.0.37 → 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/index.js

@@ -1545,17 +1545,17 @@ async function runDaemon(foreground = false, email) {
                     console.log(`[CLI] Emitted error app:control:response`);
                 }
             });
-            // Handle folder transfer — this device is the source (sender)
-            socket.on('transfer:send', (data) => {
+            // Handle folder transfer — this device is the source (pack & upload)
+            socket.on('transfer:pack', (data) => {
                 if (foreground) {
-                    console.log(`[transfer] Send request: ${data.sourcePath} → device ${data.destDeviceId.slice(0, 8)}`);
+                    console.log(`[transfer] Pack request: ${data.sourcePath} (${data.selectedItems?.length || 0} items) → device ${data.destDeviceId.slice(0, 8)}`);
                 }
                 startSending(socket, data, foreground);
             });
-            // Handle folder transfer — this device is the destination (receiver)
-            socket.on('transfer:receive', (data) => {
+            // Handle folder transfer — this device is the destination (download & extract)
+            socket.on('transfer:pull', (data) => {
                 if (foreground) {
-                    console.log(`[transfer] Receive request: device ${data.sourceDeviceId.slice(0, 8)} → ${data.destPath}`);
+                    console.log(`[transfer] Pull request: device ${data.sourceDeviceId.slice(0, 8)} → ${data.destPath} (${(data.totalBytes / (1024 * 1024)).toFixed(1)} MB)`);
                 }
                 startReceiving(socket, data, foreground);
             });

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

@@ -4,26 +4,30 @@ import fsSync from 'fs';
 import path from 'path';
 import os from 'os';
 import { createHash } from 'crypto';
+import { Readable, Transform } from 'stream';
 // ============ Transfer Service (CLI side) ============
-// Handles both sending and receiving folders via tar streaming.
-// Binary chunks flow over Socket.IO — no HTTP endpoints needed.
-const CHUNK_SIZE = 1024 * 1024; // 1MB chunks
+// Two-phase transfer via HTTP:
+//   Phase 1 (source): tar selected items → HTTP POST to backend
+//   Phase 2 (dest):   HTTP GET from backend → tar extract
+// Socket.IO carries control events + progress/log.
 // ---- Sender ----
 export function startSending(socket, transfer, foreground) {
-    const { transferId, sourcePath } = transfer;
+    const { transferId, sourcePath, selectedItems } = transfer;
     const startTime = Date.now();
+    const apiUrl = getApiUrl(socket);
     const log = (message) => {
         if (foreground)
             console.log(`[transfer:send] ${message}`);
         socket.emit('transfer:log', { transferId, side: 'source', level: 'info', message });
     };
-    const sendProgress = (bytesTransferred, totalBytes) => {
+    const sendProgress = (phase, bytesTransferred, totalBytes) => {
         const elapsed = (Date.now() - startTime) / 1000;
         const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
         const eta = speed > 0 ? (totalBytes - bytesTransferred) / speed : 0;
         socket.emit('transfer:progress', {
             transferId,
             side: 'source',
+            phase,
             bytesTransferred,
             totalBytes,
             speed: Math.round(speed),
@@ -34,55 +38,41 @@ export function startSending(socket, transfer, foreground) {
         console.error(`[transfer:send] Error: ${message}`);
         socket.emit('transfer:error', { transferId, side: 'source', message });
     };
-    log(`Starting to tar and send: ${sourcePath}`);
-    // Estimate folder size first with a quick du
+    const items = selectedItems || ['.'];
+    log(`Packing ${items.length} item(s) from ${sourcePath}`);
+    // Estimate size first
     let totalBytes = 0;
-    try {
-        const duResult = spawn('du', ['-sb', sourcePath], { timeout: 30000 });
-        let duOutput = '';
-        duResult.stdout.on('data', (d) => { duOutput += d.toString(); });
-        duResult.on('close', (code) => {
-            if (code === 0) {
-                const match = duOutput.match(/^(\d+)/);
+    const sizeEstimate = spawn('du', ['-sb', ...items.map(i => path.join(sourcePath, i))], { cwd: sourcePath });
+    let duOutput = '';
+    sizeEstimate.stdout.on('data', (d) => { duOutput += d.toString(); });
+    sizeEstimate.on('close', (code) => {
+        if (code === 0) {
+            const lines = duOutput.trim().split('\n');
+            for (const line of lines) {
+                const match = line.match(/^(\d+)/);
                 if (match)
-                    totalBytes = parseInt(match[1], 10);
+                    totalBytes += parseInt(match[1], 10);
             }
-            log(`Estimated size: ${formatBytes(totalBytes)}`);
-            doSend();
-        });
-        duResult.on('error', () => doSend());
-    }
-    catch {
-        doSend();
-    }
-    function doSend() {
-        // Spawn tar to stream the folder
-        const tar = spawn('tar', ['cf', '-', '-C', sourcePath, '.']);
+        }
+        log(`Estimated size: ${formatBytes(totalBytes)}`);
+        doPackAndUpload();
+    });
+    sizeEstimate.on('error', () => doPackAndUpload());
+    function doPackAndUpload() {
+        // Create tar with selected items
+        const tarArgs = ['cf', '-', '-C', sourcePath, ...items];
+        const tar = spawn('tar', tarArgs);
         const hash = createHash('sha256');
         let bytesTransferred = 0;
-        let seq = 0;
         let lastProgressTime = Date.now();
-        tar.stdout.on('data', (chunk) => {
-            hash.update(chunk);
-            bytesTransferred += chunk.length;
-            // Emit binary chunk
-            socket.emit('transfer:chunk', {
-                transferId,
-                seq,
-                data: chunk,
-                size: chunk.length,
-            });
-            seq++;
-            // Throttle progress updates to every 500ms
-            if (Date.now() - lastProgressTime > 500) {
-                sendProgress(bytesTransferred, totalBytes || bytesTransferred);
-                lastProgressTime = Date.now();
-            }
-        });
+        let fileCount = 0;
+        // Count files as we go (approximate from tar output)
         tar.stderr.on('data', (data) => {
             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}`);
@@ -92,19 +82,53 @@ export function startSending(socket, transfer, foreground) {
                 sendError(`tar exited with code ${code}`);
                 return;
             }
-            const duration = Date.now() - startTime;
+            log(`Packing complete. Final size: ${formatBytes(bytesTransferred)}`);
+        });
+        // Stream tar output through hash, then HTTP POST
+        const uploadUrl = `${apiUrl}/transfer/${transferId}/upload`;
+        // Pipe tar stdout → hash transform → HTTP upload
+        const hashTransform = new Transform({
+            transform(chunk, _encoding, callback) {
+                hash.update(chunk);
+                bytesTransferred += chunk.length;
+                if (Date.now() - lastProgressTime > 500) {
+                    sendProgress('uploading', bytesTransferred, totalBytes || bytesTransferred);
+                    lastProgressTime = Date.now();
+                }
+                this.push(chunk);
+                callback();
+            },
+        });
+        // Use fetch with streaming body for the upload
+        const tarStream = tar.stdout.pipe(hashTransform);
+        // Node 18+ supports ReadableStream in fetch body
+        const nodeStream = Readable.toWeb(tarStream);
+        fetch(uploadUrl, {
+            method: 'POST',
+            body: nodeStream,
+            headers: {
+                'Content-Type': 'application/x-tar',
+                'Transfer-Encoding': 'chunked',
+            },
+            duplex: 'half',
+        }).then(async (res) => {
+            if (!res.ok) {
+                const text = await res.text();
+                sendError(`Upload failed: HTTP ${res.status} ${text}`);
+                return;
+            }
             const sha256 = hash.digest('hex');
-            // Final progress
-            sendProgress(bytesTransferred, bytesTransferred);
-            // We don't send transfer:complete here — the dest does that after verification
-            // Instead, we send a source:done so the dest knows the stream is over
-            socket.emit('transfer:source:done', {
+            const duration = Date.now() - startTime;
+            // Notify backend that upload is done (only after HTTP confirms success)
+            socket.emit('transfer:uploaded', {
                 transferId,
                 totalBytes: bytesTransferred,
                 sha256,
-                duration,
+                fileCount,
             });
-            log(`Sent ${formatBytes(bytesTransferred)} in ${(duration / 1000).toFixed(1)}s (${seq} chunks)`);
+            log(`Upload complete: ${formatBytes(bytesTransferred)} in ${(duration / 1000).toFixed(1)}s (sha256: ${sha256.slice(0, 12)}...)`);
+        }).catch((err) => {
+            sendError(`Upload network error: ${err.message}`);
         });
         // Handle cancellation
         const cancelHandler = (data) => {
@@ -121,18 +145,22 @@ export function startSending(socket, transfer, foreground) {
 export function startReceiving(socket, transfer, foreground) {
     const { transferId, destPath } = transfer;
     const startTime = Date.now();
+    const apiUrl = getApiUrl(socket);
+    const expectedBytes = transfer.totalBytes || 0;
+    const expectedSha256 = transfer.sha256 || '';
     const log = (message) => {
         if (foreground)
             console.log(`[transfer:recv] ${message}`);
         socket.emit('transfer:log', { transferId, side: 'dest', level: 'info', message });
     };
-    const sendProgress = (bytesTransferred, totalBytes) => {
+    const sendProgress = (phase, bytesTransferred, totalBytes) => {
         const elapsed = (Date.now() - startTime) / 1000;
         const speed = elapsed > 0 ? bytesTransferred / elapsed : 0;
         const eta = speed > 0 ? (totalBytes - bytesTransferred) / speed : 0;
         socket.emit('transfer:progress', {
             transferId,
             side: 'dest',
+            phase,
             bytesTransferred,
             totalBytes,
             speed: Math.round(speed),
@@ -144,103 +172,109 @@ export function startReceiving(socket, transfer, foreground) {
         socket.emit('transfer:error', { transferId, side: 'dest', message });
     };
     const tmpFile = path.join(os.tmpdir(), `ttc-transfer-${transferId}.tar`);
-    log(`Ready to receive into: ${destPath}`);
-    // Ensure dest directory exists
-    mkdir(destPath, { recursive: true }).then(() => {
-        const writeStream = fsSync.createWriteStream(tmpFile);
-        const hash = createHash('sha256');
-        let bytesReceived = 0;
-        let totalExpected = 0;
-        let lastProgressTime = Date.now();
-        let sourceSha256 = '';
-        // Handle incoming chunks
-        const chunkHandler = (data) => {
-            if (data.transferId !== transferId)
+    log(`Downloading from backend...`);
+    mkdir(destPath, { recursive: true }).then(async () => {
+        try {
+            const downloadUrl = `${apiUrl}/transfer/${transferId}/download`;
+            const res = await fetch(downloadUrl);
+            if (!res.ok) {
+                sendError(`Download failed: HTTP ${res.status}`);
                 return;
-            const chunk = Buffer.isBuffer(data.data) ? data.data : Buffer.from(data.data);
-            writeStream.write(chunk);
-            hash.update(chunk);
-            bytesReceived += chunk.length;
-            if (Date.now() - lastProgressTime > 500) {
-                sendProgress(bytesReceived, totalExpected || bytesReceived);
-                lastProgressTime = Date.now();
             }
-        };
-        socket.on('transfer:chunk', chunkHandler);
-        // Handle source:done — source finished sending
-        const sourceDoneHandler = (data) => {
-            if (data.transferId !== transferId)
+            if (!res.body) {
+                sendError('Download failed: no response body');
                 return;
-            totalExpected = data.totalBytes;
-            sourceSha256 = data.sha256;
-            log(`Source finished. Received ${formatBytes(bytesReceived)} / ${formatBytes(totalExpected)}`);
-            // Finish writing and verify
-            writeStream.end(async () => {
-                try {
-                    const receivedHash = hash.digest('hex');
-                    // Verify hash
-                    if (receivedHash !== sourceSha256) {
-                        sendError(`Hash mismatch! Expected ${sourceSha256.slice(0, 16)}... got ${receivedHash.slice(0, 16)}...`);
-                        try {
-                            await unlink(tmpFile);
-                        }
-                        catch { }
-                        return;
-                    }
-                    log(`Hash verified ✓. Extracting to ${destPath}...`);
-                    // Extract tar
-                    const extractProc = spawn('tar', ['xf', tmpFile, '-C', destPath]);
-                    extractProc.on('close', async (code) => {
-                        // Cleanup temp file
-                        try {
-                            await unlink(tmpFile);
-                        }
-                        catch { }
-                        if (code !== 0) {
-                            sendError(`tar extraction failed with code ${code}`);
-                            return;
-                        }
-                        const duration = Date.now() - startTime;
-                        // Notify completion
-                        socket.emit('transfer:complete', {
-                            transferId,
-                            totalBytes: bytesReceived,
-                            sha256: receivedHash,
-                            duration,
-                        });
-                        log(`Complete! ${formatBytes(bytesReceived)} extracted to ${destPath} in ${(duration / 1000).toFixed(1)}s`);
-                        // Cleanup listeners
-                        socket.off('transfer:chunk', chunkHandler);
-                        socket.off('transfer:source:done', sourceDoneHandler);
-                    });
-                    extractProc.on('error', (err) => {
-                        sendError(`tar extraction error: ${err.message}`);
-                    });
+            }
+            // Stream download to temp file while hashing
+            const writeStream = fsSync.createWriteStream(tmpFile);
+            const hash = createHash('sha256');
+            let bytesReceived = 0;
+            let lastProgressTime = Date.now();
+            const reader = res.body.getReader();
+            // Read chunks from the response stream
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                writeStream.write(value);
+                hash.update(value);
+                bytesReceived += value.length;
+                if (Date.now() - lastProgressTime > 500) {
+                    sendProgress('downloading', bytesReceived, expectedBytes || bytesReceived);
+                    lastProgressTime = Date.now();
                 }
-                catch (err) {
-                    sendError(`Post-processing error: ${err.message}`);
+            }
+            writeStream.end();
+            log(`Downloaded ${formatBytes(bytesReceived)}. Verifying...`);
+            // Verify hash
+            const receivedHash = hash.digest('hex');
+            if (expectedSha256 && receivedHash !== expectedSha256) {
+                sendError(`Hash mismatch! Expected ${expectedSha256.slice(0, 16)}... got ${receivedHash.slice(0, 16)}...`);
+                try {
+                    await unlink(tmpFile);
                 }
+                catch { }
+                return;
+            }
+            log(`Hash verified ✓. Extracting to ${destPath}...`);
+            sendProgress('extracting', bytesReceived, bytesReceived);
+            // Extract tar
+            const extractProc = spawn('tar', ['xf', tmpFile, '-C', destPath]);
+            await new Promise((resolve, reject) => {
+                extractProc.on('close', (code) => {
+                    if (code !== 0)
+                        reject(new Error(`tar extraction failed with code ${code}`));
+                    else
+                        resolve();
+                });
+                extractProc.on('error', reject);
             });
-        };
-        socket.on('transfer:source:done', sourceDoneHandler);
-        // Handle cancellation
-        const cancelHandler = (data) => {
-            if (data.transferId === transferId) {
-                writeStream.destroy();
-                socket.off('transfer:chunk', chunkHandler);
-                socket.off('transfer:source:done', sourceDoneHandler);
-                socket.off('transfer:cancel', cancelHandler);
-                log('Transfer cancelled');
-                // Cleanup temp file
-                unlink(tmpFile).catch(() => { });
+            // Cleanup temp file
+            try {
+                await unlink(tmpFile);
             }
-        };
-        socket.on('transfer:cancel', cancelHandler);
+            catch { }
+            const duration = Date.now() - startTime;
+            socket.emit('transfer:complete', {
+                transferId,
+                totalBytes: bytesReceived,
+                sha256: receivedHash,
+                duration,
+                fileCount: 0,
+            });
+            log(`Complete! ${formatBytes(bytesReceived)} extracted to ${destPath} in ${(duration / 1000).toFixed(1)}s`);
+        }
+        catch (err) {
+            sendError(`Download/extract error: ${err.message}`);
+            try {
+                await unlink(tmpFile);
+            }
+            catch { }
+        }
     }).catch((err) => {
         sendError(`Failed to create destination directory: ${err.message}`);
     });
 }
 // ---- Helpers ----
+function getApiUrl(socket) {
+    // Extract the base URL from the socket connection
+    const io = socket.io;
+    const opts = io.opts;
+    if (opts?.hostname) {
+        const protocol = opts.secure !== false ? 'https' : 'http';
+        const port = opts.port ? `:${opts.port}` : '';
+        return `${protocol}://${opts.hostname}${port}`;
+    }
+    // Fallback: read from config
+    try {
+        const configPath = path.join(os.homedir(), '.talk-to-code', 'config.json');
+        const config = JSON.parse(fsSync.readFileSync(configPath, 'utf-8'));
+        return config.apiUrl || 'https://api.talk-to-code.com';
+    }
+    catch {
+        return 'https://api.talk-to-code.com';
+    }
+}
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';

package/package.json

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