@exreve/exk 1.0.37 → 1.0.38

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/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,51 +38,35 @@ 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)
@@ -92,19 +80,52 @@ 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)}`);
             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
+            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)}...)`);
+        });
+        // 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}`);
+            }
+        }).catch((err) => {
+            sendError(`Upload network error: ${err.message}`);
         });
         // Handle cancellation
         const cancelHandler = (data) => {
@@ -121,18 +142,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 +169,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.38",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {