@nightowne/tas-cli 2.1.0 → 2.3.0

package/src/fuse/mount.js

@@ -5,21 +5,38 @@
  * This is the killer feature - use Telegram like a regular folder!
  */
 
-import Fuse from 'fuse-native';
 import path from 'path';
 import fs from 'fs';
+import crypto from 'crypto';
+import { processFile } from '../index.js';
+
+let Fuse;
+try {
+    Fuse = (await import('fuse-native')).default;
+} catch {
+    // fuse-native is optional — unavailable on ARM64 or systems without libfuse
+}
 import { TelegramClient } from '../telegram/client.js';
 import { Encryptor } from '../crypto/encryption.js';
 import { Compressor } from '../utils/compression.js';
 import { FileIndex } from '../db/index.js';
 import { createHeader, parseHeader, HEADER_SIZE } from '../utils/chunker.js';
 
-// File cache for performance (avoid re-downloading)
-const fileCache = new Map();
 const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+const CACHE_MAX_ENTRIES = 100; // Prevent unbounded memory growth
 
 export class TelegramFS {
     constructor(options) {
+        if (!Fuse) {
+            throw new Error(
+                'fuse-native is not available on this system.\n' +
+                '  On Linux x86_64: npm install fuse-native && sudo apt install fuse libfuse-dev\n' +
+                '  On macOS: brew install macfuse && npm install fuse-native\n' +
+                '  On ARM64: see https://github.com/ixchio/tas/issues/1 for a workaround\n' +
+                '  All other TAS commands (push, pull, sync, share) work without FUSE.'
+            );
+        }
+
         this.dataDir = options.dataDir;
         this.password = options.password;
         this.config = options.config;
@@ -35,6 +52,9 @@ export class TelegramFS {
 
         // Pending writes buffer
         this.writeBuffers = new Map();
+        
+        // Instance-level file cache to prevent cross-talk
+        this.fileCache = new Map();
     }
 
     async initialize() {
@@ -70,7 +90,7 @@ export class TelegramFS {
                 mtime: new Date(),
                 atime: new Date(),
                 ctime: new Date(),
-                size: wb.data.length,
+                size: wb.size,
                 mode: 0o100644, // regular file
                 uid: process.getuid?.() || 0,
                 gid: process.getgid?.() || 0
@@ -104,9 +124,14 @@ export class TelegramFS {
         }
 
         const files = this.db.listAll();
-        const names = files.map(f => f.filename);
+        const nameSet = new Set(files.map(f => f.filename));
+
+        // Include files currently being written (not yet released/uploaded)
+        for (const name of this.writeBuffers.keys()) {
+            nameSet.add(name);
+        }
 
-        return cb(0, names);
+        return cb(0, [...nameSet]);
     }
 
     /**
@@ -139,9 +164,8 @@ export class TelegramFS {
             // Check write buffers first
             const wb = this.writeBuffers.get(filename);
             if (wb) {
-                const slice = wb.data.subarray(position, position + length);
-                slice.copy(buffer);
-                return cb(slice.length);
+                const bytesRead = fs.readSync(wb.fd, buffer, 0, length, position);
+                return cb(bytesRead);
             }
 
             // Check cache first
@@ -166,34 +190,55 @@ export class TelegramFS {
     }
 
     /**
-     * Write to a file (buffers until release)
+     * Helper to get or create a disk-buffered write structure
      */
-    write(filepath, fd, buffer, length, position, cb) {
-        const filename = path.basename(filepath);
+    getOrCreateWriteBuffer(filename) {
+        if (this.writeBuffers.has(filename)) {
+            return this.writeBuffers.get(filename);
+        }
 
-        // Get or create write buffer
-        if (!this.writeBuffers.has(filename)) {
-            this.writeBuffers.set(filename, {
-                data: Buffer.alloc(0),
-                modified: true
-            });
+        const fuseTmpDir = path.join(this.dataDir, 'fuse-tmp');
+        if (!fs.existsSync(fuseTmpDir)) {
+            fs.mkdirSync(fuseTmpDir, { recursive: true });
         }
 
-        const wb = this.writeBuffers.get(filename);
+        const tmpPath = path.join(fuseTmpDir, crypto.randomBytes(16).toString('hex'));
+        const fdDisk = fs.openSync(tmpPath, 'w+');
 
-        // Expand buffer if needed
-        const newSize = Math.max(wb.data.length, position + length);
-        if (newSize > wb.data.length) {
-            const newBuf = Buffer.alloc(newSize);
-            wb.data.copy(newBuf);
-            wb.data = newBuf;
+        // Check if there is an existing file cached
+        const cachedPath = this.getCached(filename);
+        let size = 0;
+        if (cachedPath && fs.existsSync(cachedPath)) {
+            const content = fs.readFileSync(cachedPath);
+            fs.writeSync(fdDisk, content, 0, content.length, 0);
+            size = content.length;
         }
 
-        // Copy incoming data
-        buffer.copy(wb.data, position, 0, length);
-        wb.modified = true;
+        const wb = {
+            tmpPath,
+            fd: fdDisk,
+            size,
+            modified: true
+        };
+        this.writeBuffers.set(filename, wb);
+        return wb;
+    }
 
-        return cb(length);
+    /**
+     * Write to a file (buffers until release)
+     */
+    write(filepath, fd, buffer, length, position, cb) {
+        const filename = path.basename(filepath);
+        try {
+            const wb = this.getOrCreateWriteBuffer(filename);
+            fs.writeSync(wb.fd, buffer, 0, length, position);
+            wb.size = Math.max(wb.size, position + length);
+            wb.modified = true;
+            return cb(length);
+        } catch (err) {
+            console.error('[FUSE] Write error:', err.message);
+            return cb(Fuse.EIO);
+        }
     }
 
     /**
@@ -204,9 +249,19 @@ export class TelegramFS {
 
         console.log(`[FUSE] Creating file: ${filename}`);
 
-        // Initialize empty write buffer
+        // Initialize empty disk-buffered write
+        const fuseTmpDir = path.join(this.dataDir, 'fuse-tmp');
+        if (!fs.existsSync(fuseTmpDir)) {
+            fs.mkdirSync(fuseTmpDir, { recursive: true });
+        }
+
+        const tmpPath = path.join(fuseTmpDir, crypto.randomBytes(16).toString('hex'));
+        const fdDisk = fs.openSync(tmpPath, 'w+');
+
         this.writeBuffers.set(filename, {
-            data: Buffer.alloc(0),
+            tmpPath,
+            fd: fdDisk,
+            size: 0,
             modified: true,
             isNew: true
         });
@@ -228,15 +283,26 @@ export class TelegramFS {
         const filename = path.basename(filepath);
 
         const wb = this.writeBuffers.get(filename);
-        if (!wb || !wb.modified) {
+        if (!wb) {
+            return cb(0);
+        }
+
+        if (!wb.modified) {
+            try { fs.closeSync(wb.fd); } catch (e) {}
+            try { fs.unlinkSync(wb.tmpPath); } catch (e) {}
+            this.writeBuffers.delete(filename);
             return cb(0);
         }
 
         try {
-            // Upload to Telegram
-            await this.uploadFile(filename, wb.data);
+            // Close fd so we can read and upload cleanly
+            try { fs.closeSync(wb.fd); } catch (e) {}
+
+            // Upload to Telegram from the temp path
+            await this.uploadFile(filename, wb.tmpPath);
 
-            // Clear write buffer
+            // Clean up temp file
+            try { fs.unlinkSync(wb.tmpPath); } catch (e) {}
             this.writeBuffers.delete(filename);
 
             // Invalidate cache
@@ -244,7 +310,9 @@ export class TelegramFS {
 
             return cb(0);
         } catch (err) {
-            console.error('Release error:', err.message);
+            console.error('[FUSE] Release error:', err.message);
+            try { fs.unlinkSync(wb.tmpPath); } catch (e) {}
+            this.writeBuffers.delete(filename);
             return cb(Fuse.EIO);
         }
     }
@@ -261,7 +329,7 @@ export class TelegramFS {
         }
 
         try {
-            // Delete from Telegram (optional - could just remove from index)
+            // Delete from Telegram
             const chunks = this.db.getChunks(file.id);
             for (const chunk of chunks) {
                 await this.client.deleteMessage(chunk.message_id);
@@ -275,7 +343,7 @@ export class TelegramFS {
 
             return cb(0);
         } catch (err) {
-            console.error('Unlink error:', err.message);
+            console.error('[FUSE] Unlink error:', err.message);
             return cb(Fuse.EIO);
         }
     }
@@ -297,10 +365,10 @@ export class TelegramFS {
             .run(newName, file.id);
 
         // Update cache key
-        const cached = fileCache.get(oldName);
+        const cached = this.fileCache.get(oldName);
         if (cached) {
-            fileCache.delete(oldName);
-            fileCache.set(newName, cached);
+            this.fileCache.delete(oldName);
+            this.fileCache.set(newName, cached);
         }
 
         return cb(0);
@@ -311,35 +379,16 @@ export class TelegramFS {
      */
     truncate(filepath, size, cb) {
         const filename = path.basename(filepath);
-
-        // Get or load into write buffer
-        if (!this.writeBuffers.has(filename)) {
-            const cachedPath = this.getCached(filename);
-            if (cachedPath) {
-                this.writeBuffers.set(filename, {
-                    data: fs.readFileSync(cachedPath), // Note: RAM buffer here could be big, but it's okay for truncate/writes right now
-                    modified: true
-                });
-            } else {
-                this.writeBuffers.set(filename, {
-                    data: Buffer.alloc(0),
-                    modified: true
-                });
-            }
-        }
-
-        const wb = this.writeBuffers.get(filename);
-
-        if (size < wb.data.length) {
-            wb.data = wb.data.subarray(0, size);
-        } else if (size > wb.data.length) {
-            const newBuf = Buffer.alloc(size);
-            wb.data.copy(newBuf);
-            wb.data = newBuf;
+        try {
+            const wb = this.getOrCreateWriteBuffer(filename);
+            fs.ftruncateSync(wb.fd, size);
+            wb.size = size;
+            wb.modified = true;
+            return cb(0);
+        } catch (err) {
+            console.error('[FUSE] Truncate error:', err.message);
+            return cb(Fuse.EIO);
         }
-
-        wb.modified = true;
-        return cb(0);
     }
 
     // ============== Helper Methods ==============
@@ -421,10 +470,7 @@ export class TelegramFS {
         return outputPath;
     }
 
-    async uploadFile(filename, data) {
-        const { hashData } = await import('../crypto/encryption.js');
-        const hash = hashData(data);
-
+    async uploadFile(filename, tempPath) {
         // Check if already exists by name
         const existingByName = this.db.findByName(filename);
         if (existingByName) {
@@ -436,57 +482,17 @@ export class TelegramFS {
             this.db.delete(existingByName.id);
         }
 
-        // Check if already exists by hash (same content, different name)
-        const existingByHash = this.db.findByHash(hash);
-        if (existingByHash) {
-            // Same content already exists, just skip
-            console.log(`[FUSE] File with same content already exists as ${existingByHash.filename}`);
-            return;
-        }
-
-        // Compress
-        const { data: compressedData, compressed } = await this.compressor.compress(data, filename);
-
-        // Encrypt
-        const encryptedData = this.encryptor.encrypt(compressedData);
-
-        // Create temp file with header
-        const tempDir = process.env.TAS_TMP_DIR || path.join(this.dataDir, 'tmp');
-        if (!fs.existsSync(tempDir)) {
-            fs.mkdirSync(tempDir, { recursive: true });
-        }
-
-        const flags = compressed ? 1 : 0;
-        const header = createHeader(filename, data.length, 0, 1, flags);
-        const fileData = Buffer.concat([header, encryptedData]);
-
-        const tempPath = path.join(tempDir, `${hash.substring(0, 12)}.tas`);
-        fs.writeFileSync(tempPath, fileData);
-
-        // Upload to Telegram
-        const result = await this.client.sendFile(tempPath, `📦 ${filename}`);
-
-        // Add to index
-        const fileId = this.db.addFile({
-            filename,
-            hash,
-            originalSize: data.length,
-            storedSize: encryptedData.length,
-            chunks: 1,
-            compressed
+        // Run the standard chunked upload pipeline (this handles chunking, encryption, compression, and DB entry)
+        await processFile(tempPath, {
+            password: this.password,
+            dataDir: this.dataDir,
+            customName: filename,
+            config: this.config
         });
-
-        this.db.addChunk(fileId, 0, result.messageId.toString(), fileData.length);
-        this.db.db.prepare('UPDATE chunks SET file_telegram_id = ? WHERE file_id = ? AND chunk_index = ?')
-            .run(result.fileId, fileId, 0);
-
-        // Cleanup
-        fs.unlinkSync(tempPath);
-        try { fs.rmdirSync(tempDir); } catch (e) { }
     }
 
     getCached(filename) {
-        const entry = fileCache.get(filename);
+        const entry = this.fileCache.get(filename);
         if (!entry) return null;
 
         if (Date.now() - entry.timestamp > CACHE_TTL) {
@@ -494,7 +500,7 @@ export class TelegramFS {
             try {
                 if (fs.existsSync(entry.path)) fs.unlinkSync(entry.path);
             } catch (e) { }
-            fileCache.delete(filename);
+            this.fileCache.delete(filename);
             return null;
         }
 
@@ -504,19 +510,36 @@ export class TelegramFS {
     }
 
     setCache(filename, cachePath) {
-        fileCache.set(filename, {
+        // Evict oldest entry if cache is full
+        if (this.fileCache.size >= CACHE_MAX_ENTRIES) {
+            let oldestKey = null;
+            let oldestTime = Infinity;
+            for (const [key, entry] of this.fileCache) {
+                if (entry.timestamp < oldestTime) {
+                    oldestTime = entry.timestamp;
+                    oldestKey = key;
+                }
+            }
+            if (oldestKey) {
+                const evicted = this.fileCache.get(oldestKey);
+                try { if (fs.existsSync(evicted.path)) fs.unlinkSync(evicted.path); } catch (e) { }
+                this.fileCache.delete(oldestKey);
+            }
+        }
+
+        this.fileCache.set(filename, {
             path: cachePath,
             timestamp: Date.now()
         });
     }
 
     invalidateCache(filename) {
-        const entry = fileCache.get(filename);
+        const entry = this.fileCache.get(filename);
         if (entry) {
             try {
                 if (fs.existsSync(entry.path)) fs.unlinkSync(entry.path);
             } catch (e) { }
-            fileCache.delete(filename);
+            this.fileCache.delete(filename);
         }
     }
 
@@ -529,6 +552,17 @@ export class TelegramFS {
             fs.mkdirSync(this.mountPoint, { recursive: true });
         }
 
+        // Clean up any stray temp files from previous sessions
+        const fuseTmpDir = path.join(this.dataDir, 'fuse-tmp');
+        if (fs.existsSync(fuseTmpDir)) {
+            try {
+                const files = fs.readdirSync(fuseTmpDir);
+                for (const file of files) {
+                    fs.unlinkSync(path.join(fuseTmpDir, file));
+                }
+            } catch (e) {}
+        }
+
         const ops = {
             getattr: this.getattr.bind(this),
             readdir: this.readdir.bind(this),

package/src/index.js

@@ -8,7 +8,7 @@ import path from 'path';
 import { pipeline } from 'stream/promises';
 import { Encryptor, hashFile } from './crypto/encryption.js';
 import { Compressor } from './utils/compression.js';
-import { Chunker, createHeader, parseHeader, HEADER_SIZE } from './utils/chunker.js';
+import { createHeader, parseHeader, HEADER_SIZE } from './utils/chunker.js';
 import { TelegramClient } from './telegram/client.js';
 import { FileIndex } from './db/index.js';
 
@@ -72,15 +72,23 @@ export async function processFile(filePath, options) {
     if (compressed && originalSize > 1024 * 1024) estimatedSize = originalSize * 0.8; // Rough guess
     let estimatedChunks = Math.ceil(estimatedSize / TELEGRAM_CHUNK_SIZE) || 1;
 
-    // Register file in DB
-    const fileId = db.addFile({
-        filename,
-        hash,
-        originalSize,
-        storedSize: 0, // Will update later
-        chunks: estimatedChunks,
-        compressed
-    });
+    // Register file in DB inside a transaction for atomicity
+    db.db.exec('BEGIN');
+    let fileId;
+    try {
+        fileId = db.addFile({
+            filename,
+            hash,
+            originalSize,
+            storedSize: 0, // Will update later
+            chunks: estimatedChunks,
+            compressed
+        });
+    } catch (err) {
+        db.db.exec('ROLLBACK');
+        db.close();
+        throw err;
+    }
 
     onProgress?.('Processing and uploading streams...');
     let uploadedBytes = 0;
@@ -162,22 +170,33 @@ export async function processFile(filePath, options) {
         }
     });
 
-    const readStream = fs.createReadStream(filePath);
+    try {
+        const readStream = fs.createReadStream(filePath);
 
-    // Run the pipeline: Read -> Compress -> Encrypt -> Chunk & Upload
-    await pipeline(readStream, compressStream, encryptStream, chunkingStream);
+        // Run the pipeline: Read -> Compress -> Encrypt -> Chunk & Upload
+        await pipeline(readStream, compressStream, encryptStream, chunkingStream);
+    } catch (pipelineErr) {
+        // Pipeline failed — roll back the DB transaction so no orphaned rows remain
+        try { db.db.exec('ROLLBACK'); } catch (e) { /* already rolled back */ }
+        db.close();
+        throw pipelineErr;
+    }
 
     // Update the DB with the final accurate values 
     db.db.prepare('UPDATE files SET stored_size = ?, chunks = ? WHERE id = ?')
         .run(totalStoredSize, chunkIndex, fileId);
 
+    // Commit the transaction — all DB rows are now permanent
+    db.db.exec('COMMIT');
+
     db.close();
 
-    // Clean up temp dir
+    // Clean up temp dir (only if empty)
     try {
-        fs.rmdirSync(tempDir);
+        const remaining = fs.readdirSync(tempDir);
+        if (remaining.length === 0) fs.rmdirSync(tempDir);
     } catch (e) {
-        // Ignore if not empty
+        // Ignore cleanup errors
     }
 
     return {
@@ -292,8 +311,16 @@ export async function retrieveFile(fileRecord, options) {
 
     const finalStats = fs.statSync(outputPath);
 
+    // Verify file integrity by comparing hash
+    onProgress?.('Verifying file integrity...');
+    const downloadedHash = await hashFile(outputPath);
+    if (fileRecord.hash && downloadedHash !== fileRecord.hash) {
+        throw new Error(`Integrity check failed: expected hash ${fileRecord.hash.substring(0, 12)}..., got ${downloadedHash.substring(0, 12)}...`);
+    }
+
     return {
         path: outputPath,
-        size: finalStats.size
+        size: finalStats.size,
+        verified: true
     };
 }

package/src/share/server.js

@@ -57,6 +57,25 @@ function formatTimeLeft(expiresAt) {
     return `${minutes}m`;
 }
 
+/**
+ * Escape HTML special characters to prevent XSS
+ */
+function escapeHtml(str) {
+    return String(str)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#x27;');
+}
+
+/**
+ * Sanitize filename for Content-Disposition header (RFC 6266)
+ */
+function sanitizeFilenameForHeader(filename) {
+    return filename.replace(/["\\\r\n]/g, '_');
+}
+
 /**
  * Generate the download HTML page
  */
@@ -69,6 +88,7 @@ function generateDownloadPage(share, fileRecord) {
         : fileSize > 1024
             ? `${(fileSize / 1024).toFixed(1)} KB`
             : `${fileSize} B`;
+    const safeFilename = escapeHtml(fileRecord.filename);
 
     return `<!DOCTYPE html>
 <html lang="en">
@@ -146,7 +166,7 @@ function generateDownloadPage(share, fileRecord) {
     <div class="card">
         <div class="icon">🔐</div>
         <h1>Secure File Share</h1>
-        <div class="filename">${fileRecord.filename}</div>
+        <div class="filename">${safeFilename}</div>
         <div class="meta">
             <span>📦 ${sizeStr}</span>
             <span>⏳ ${timeLeft}</span>
@@ -241,16 +261,20 @@ export class ShareServer {
     }
 
     /**
-     * Stream a decrypted file from Telegram directly to the HTTP response
+     * Prepare download streams from Telegram — fetches and verifies
+     * the first chunk before returning, so the caller can decide
+     * whether to commit to a 200 response.
+     *
+     * Returns: { downloadStream, decryptStream, decompressStream }
      */
-    async streamToResponse(fileRecord, res) {
+    async prepareDownloadStreams(fileRecord) {
         const chunks = this.db.getChunks(fileRecord.id);
         if (chunks.length === 0) throw new Error('No chunks found');
 
         // Pre-sort chunks by index so we download them in correct order
         chunks.sort((a, b) => a.chunk_index - b.chunk_index);
 
-        // Get total size from first chunk's header
+        // Fetch and verify the first chunk eagerly
         const firstChunkData = await this.client.downloadFile(chunks[0].file_telegram_id);
         const header = parseHeader(firstChunkData);
         let wasCompressed = header.compressed;
@@ -259,9 +283,7 @@ export class ShareServer {
         const decryptStream = this.encryptor.getDecryptStream();
         const decompressStream = this.compressor.getDecompressStream(wasCompressed);
 
-        // We need a Readable stream that will lazily fetch chunks from Telegram
         const { Readable } = await import('stream');
-        const { pipeline } = await import('stream/promises');
 
         const self = this;
         let currentChunkIndex = 0;
@@ -296,8 +318,7 @@ export class ShareServer {
             }
         });
 
-        // Pipeline: Download from Telegram -> Decrypt -> Decompress -> HTTP Response
-        await pipeline(downloadStream, decryptStream, decompressStream, res);
+        return { downloadStream, decryptStream, decompressStream };
     }
 
     /**
@@ -378,15 +399,33 @@ export class ShareServer {
                 '.mp3': 'audio/mpeg'
             };
             const contentType = contentTypes[ext] || 'application/octet-stream';
+            const safeName = sanitizeFilenameForHeader(fileRecord.filename);
+
+            try {
+                // Verify first chunk can be fetched and decrypted BEFORE sending 200 OK.
+                // This prevents sending a truncated/corrupt file on Telegram or decrypt failure.
+                const { downloadStream, decryptStream, decompressStream } = await this.prepareDownloadStreams(fileRecord);
+
+                // First chunk verified — commit to the 200 response
+                res.writeHead(200, {
+                    'Content-Type': contentType,
+                    'Content-Disposition': `attachment; filename="${safeName}"; filename*=UTF-8''${encodeURIComponent(fileRecord.filename)}`,
+                    'Transfer-Encoding': 'chunked'
+                });
 
-            res.writeHead(200, {
-                'Content-Type': contentType,
-                'Content-Disposition': `attachment; filename="${fileRecord.filename}"`,
-                'Content-Length': fileRecord.original_size
-            });
-
-            // Download the file from Telegram, decrypt, decompress and stream directly to 'res'
-            await this.streamToResponse(fileRecord, res);
+                const { pipeline } = await import('stream/promises');
+                await pipeline(downloadStream, decryptStream, decompressStream, res);
+            } catch (streamErr) {
+                console.error('Share stream error:', streamErr.message);
+                // Headers not yet sent — we can still return a proper error
+                if (!res.headersSent) {
+                    res.writeHead(500, { 'Content-Type': 'text/plain' });
+                    res.end('Download failed — file could not be decrypted or fetched.');
+                } else {
+                    // Headers already sent (shouldn't happen now, but safety net)
+                    res.end();
+                }
+            }
 
         } catch (err) {
             console.error('Share server error:', err.message);