@nightowne/tas-cli 2.1.0 → 2.4.0

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, HEADER_SIZE } from './utils/chunker.js';
 import { TelegramClient } from './telegram/client.js';
 import { FileIndex } from './db/index.js';
 
@@ -173,11 +173,12 @@ export async function processFile(filePath, options) {
 
     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 {
@@ -209,91 +210,45 @@ export async function retrieveFile(fileRecord, options) {
         throw new Error('No chunk metadata found for this file');
     }
 
-    // Prepare components
-    const encryptor = new Encryptor(password);
-    const decryptStream = encryptor.getDecryptStream();
-
-    const tempDir = process.env.TAS_TMP_DIR || path.join(dataDir, 'tmp');
-    if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true });
-    }
-
     // Connect to Telegram
     const client = new TelegramClient(dataDir);
     await client.initialize(config.botToken);
     client.setChatId(config.chatId);
 
-    // Get total size from first chunk's header, or from DB
-    const firstChunkData = await client.downloadFile(chunks[0].file_telegram_id);
-    const header = parseHeader(firstChunkData);
-
-    // Total original uncompressed size
-    let expectedOriginalSize = header.originalSize;
-    let wasCompressed = header.compressed;
-
+    const encryptor = new Encryptor(password);
     const compressor = new Compressor();
-    const decompressStream = compressor.getDecompressStream(wasCompressed);
-
-    // We need a Readable stream that will lazily fetch chunks from Telegram
-    // and push them into the decryption pipeline.
-    const { Readable } = await import('stream');
-
-    const totalBytes = fileRecord.stored_size || chunks.reduce((acc, c) => acc + (c.size || 0), 0);
-    let downloadedBytes = 0;
-
-    // Pre-sort chunks by index so we download them in correct order
-    chunks.sort((a, b) => a.chunk_index - b.chunk_index);
 
-    let currentChunkIndex = 0;
+    const { createDownloadPipeline } = await import('./utils/download-stream.js');
 
-    // We already downloaded the first chunk to inspect its header, we shouldn't discard it.
-    let preloadedFirstChunk = firstChunkData;
-
-    const downloadStream = new Readable({
-        async read() {
-            try {
-                if (currentChunkIndex >= chunks.length) {
-                    this.push(null); // End of stream
-                    return;
-                }
-
-                const chunk = chunks[currentChunkIndex];
-                onProgress?.(`Downloading chunk ${chunk.chunk_index + 1}/${chunks.length}...`);
-
-                let data;
-                if (currentChunkIndex === 0 && preloadedFirstChunk) {
-                    data = preloadedFirstChunk;
-                    preloadedFirstChunk = null;
-                } else {
-                    data = await client.downloadFile(chunk.file_telegram_id);
-                }
-
-                downloadedBytes += data.length;
-                onByteProgress?.({ downloaded: downloadedBytes, total: totalBytes, chunk: chunk.chunk_index + 1, totalChunks: chunks.length });
-
-                // Strip header before pushing
-                const payload = data.subarray(HEADER_SIZE);
-                this.push(payload);
-
-                currentChunkIndex++;
-            } catch (err) {
-                this.destroy(err);
-            }
+    const { readable } = await createDownloadPipeline({
+        client,
+        chunks,
+        encryptor,
+        compressor,
+        onChunkDownloaded({ chunkIndex, totalChunks, bytesDownloaded, totalBytes }) {
+            onProgress?.(`Downloading chunk ${chunkIndex + 1}/${totalChunks}...`);
+            onByteProgress?.({ downloaded: bytesDownloaded, total: totalBytes, chunk: chunkIndex + 1, totalChunks });
         }
     });
 
     const writeStream = fs.createWriteStream(outputPath);
-    const { pipeline } = await import('stream/promises');
 
     onProgress?.('Decrypting, decompressing, and writing file...');
 
-    // Pipeline: Download from Telegram -> Decrypt -> Decompress -> Disk
-    await pipeline(downloadStream, decryptStream, decompressStream, writeStream);
+    await pipeline(readable, writeStream);
 
     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

@@ -7,11 +7,12 @@
 import http from 'http';
 import crypto from 'crypto';
 import path from 'path';
+import { pipeline } from 'stream/promises';
 import { FileIndex } from '../db/index.js';
 import { TelegramClient } from '../telegram/client.js';
 import { Encryptor } from '../crypto/encryption.js';
 import { Compressor } from '../utils/compression.js';
-import { parseHeader, HEADER_SIZE } from '../utils/chunker.js';
+import { createDownloadPipeline } from '../utils/download-stream.js';
 
 /**
  * Generate a secure random share token
@@ -57,6 +58,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 +89,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 +167,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>
@@ -219,7 +240,7 @@ export class ShareServer {
         this.password = options.password;
         this.config = options.config;
         this.port = options.port || 3000;
-        this.host = options.host || '0.0.0.0';
+        this.host = options.host || '127.0.0.1';
 
         this.db = null;
         this.client = null;
@@ -245,59 +266,15 @@ export class ShareServer {
      */
     async streamToResponse(fileRecord, res) {
         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
-        const firstChunkData = await this.client.downloadFile(chunks[0].file_telegram_id);
-        const header = parseHeader(firstChunkData);
-        let wasCompressed = header.compressed;
-
-        // Prepare streams
-        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;
-        let preloadedFirstChunk = firstChunkData;
-
-        const downloadStream = new Readable({
-            async read() {
-                try {
-                    if (currentChunkIndex >= chunks.length) {
-                        this.push(null); // End of stream
-                        return;
-                    }
-
-                    const chunk = chunks[currentChunkIndex];
-                    let data;
-
-                    if (currentChunkIndex === 0 && preloadedFirstChunk) {
-                        data = preloadedFirstChunk;
-                        preloadedFirstChunk = null;
-                    } else {
-                        data = await self.client.downloadFile(chunk.file_telegram_id);
-                    }
-
-                    // Strip header before pushing
-                    const payload = data.subarray(HEADER_SIZE);
-                    this.push(payload);
-
-                    currentChunkIndex++;
-                } catch (err) {
-                    this.destroy(err);
-                }
-            }
+
+        const { readable } = await createDownloadPipeline({
+            client: this.client,
+            chunks,
+            encryptor: this.encryptor,
+            compressor: this.compressor
         });
 
-        // Pipeline: Download from Telegram -> Decrypt -> Decompress -> HTTP Response
-        await pipeline(downloadStream, decryptStream, decompressStream, res);
+        await pipeline(readable, res);
     }
 
     /**
@@ -378,11 +355,12 @@ export class ShareServer {
                 '.mp3': 'audio/mpeg'
             };
             const contentType = contentTypes[ext] || 'application/octet-stream';
+            const safeName = sanitizeFilenameForHeader(fileRecord.filename);
 
             res.writeHead(200, {
                 'Content-Type': contentType,
-                'Content-Disposition': `attachment; filename="${fileRecord.filename}"`,
-                'Content-Length': fileRecord.original_size
+                'Content-Disposition': `attachment; filename="${safeName}"; filename*=UTF-8''${encodeURIComponent(fileRecord.filename)}`,
+                'Transfer-Encoding': 'chunked'
             });
 
             // Download the file from Telegram, decrypt, decompress and stream directly to 'res'

package/src/telegram/client.js

@@ -1,6 +1,7 @@
 /**
  * Telegram Bot client wrapper
  * Uses official Telegram Bot API - 2GB file limit, FREE, no ban risk!
+ * Includes exponential backoff retry and rate limiting for production reliability.
  */
 
 import TelegramBot from 'node-telegram-bot-api';
@@ -8,11 +9,46 @@ import fs from 'fs';
 import path from 'path';
 import { pipeline } from 'stream/promises';
 
+const MAX_RETRIES = 5;
+const BASE_DELAY_MS = 1000;
+const MAX_DELAY_MS = 60000;
+
+/**
+ * Retry an async function with exponential backoff + jitter.
+ * Handles Telegram 429 (rate limit) errors by respecting retry_after.
+ */
+async function withRetry(fn, label = 'operation', retries = MAX_RETRIES) {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            return await fn();
+        } catch (err) {
+            const isRateLimit = err?.response?.statusCode === 429 || err?.message?.includes('429');
+            const isTransient = err?.code === 'ETIMEOUT' || err?.code === 'ECONNRESET' ||
+                err?.code === 'ENOTFOUND' || err?.message?.includes('ETIMEDOUT');
+
+            if (attempt >= retries) throw err;
+            if (!isRateLimit && !isTransient) throw err;
+
+            let delay;
+            if (isRateLimit && err?.response?.body?.parameters?.retry_after) {
+                delay = err.response.body.parameters.retry_after * 1000 + 500;
+            } else {
+                delay = Math.min(BASE_DELAY_MS * Math.pow(2, attempt) + Math.random() * 1000, MAX_DELAY_MS);
+            }
+
+            const sec = (delay / 1000).toFixed(1);
+            console.log(`⏳ ${label} failed (attempt ${attempt + 1}/${retries + 1}), retrying in ${sec}s...`);
+            await new Promise(r => setTimeout(r, delay));
+        }
+    }
+}
+
 export class TelegramClient {
     constructor(dataDir) {
         this.dataDir = dataDir;
         this.bot = null;
         this.chatId = null;
+        this._lastSendTime = 0;
     }
 
     /**
@@ -76,9 +112,22 @@ export class TelegramClient {
         });
     }
 
+    /**
+     * Rate-limit: ensure at least 1s between sends to same chat (Telegram limit)
+     */
+    async _rateLimit() {
+        const now = Date.now();
+        const elapsed = now - this._lastSendTime;
+        if (elapsed < 1000) {
+            await new Promise(r => setTimeout(r, 1000 - elapsed));
+        }
+        this._lastSendTime = Date.now();
+    }
+
     /**
      * Send a file to the storage chat
      * Telegram supports up to 2GB for documents!
+     * Includes automatic retry with exponential backoff.
      */
     async sendFile(filePath, caption = '', options = {}) {
         if (!this.chatId) {
@@ -89,9 +138,12 @@ export class TelegramClient {
             throw new Error(`File not found: ${filePath}`);
         }
 
-        try {
+        const filename = path.basename(filePath);
+
+        return withRetry(async () => {
+            await this._rateLimit();
+
             let fileStream = fs.createReadStream(filePath);
-            const filename = path.basename(filePath);
 
             if (options.limitRate) {
                 const { Throttle } = await import('../utils/throttle.js');
@@ -110,28 +162,24 @@ export class TelegramClient {
                 fileId: message.document.file_id,
                 timestamp: message.date
             };
-        } catch (err) {
-            throw new Error(`Failed to upload to Telegram: ${err.message}`);
-        }
+        }, `Upload ${filename}`);
     }
 
     /**
      * Download a file from Telegram (In-Memory buffer)
+     * Includes automatic retry with exponential backoff.
      */
     async downloadFile(fileId) {
-        // Get file path from Telegram servers
-        const file = await this.bot.getFile(fileId);
-
-        // Download the file
-        const fileStream = await this.bot.getFileStream(fileId);
+        return withRetry(async () => {
+            const fileStream = await this.bot.getFileStream(fileId);
 
-        // Collect chunks into buffer
-        const chunks = [];
-        for await (const chunk of fileStream) {
-            chunks.push(chunk);
-        }
+            const chunks = [];
+            for await (const chunk of fileStream) {
+                chunks.push(chunk);
+            }
 
-        return Buffer.concat(chunks);
+            return Buffer.concat(chunks);
+        }, `Download ${fileId.substring(0, 12)}...`);
     }
 
     /**

package/src/utils/branding.js

@@ -14,7 +14,7 @@ export const LOGO = `
 `;
 
 export const TAGLINE = 'Telegram as Storage';
-export const VERSION = '1.0.0';
+export const VERSION = '2.4.0';
 
 /**
  * Print the TAS banner
@@ -57,10 +57,10 @@ export function warn(msg) {
  * Format file size
  */
 export function formatSize(bytes) {
-    if (bytes === 0) return '0 B';
+    if (!Number.isFinite(bytes) || bytes <= 0) return '0 B';
     const k = 1024;
     const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 

package/src/utils/chunker.js

@@ -1,9 +1,11 @@
 /**
  * File chunking utilities for large files
- * WhatsApp document limit is ~2GB, we use 1.9GB chunks to be safe
+ * Telegram Bot API limit is 50 MB for bot uploads (sendDocument).
+ * We use 49 MB to leave room for the 64-byte WAS1 header.
+ * See: https://core.telegram.org/bots/api#senddocument
  */
 
-const MAX_CHUNK_SIZE = 1.9 * 1024 * 1024 * 1024; // 1.9 GB
+const MAX_CHUNK_SIZE = 49 * 1024 * 1024; // 49 MB — Telegram Bot API safe limit
 
 export class Chunker {
     /**

package/src/utils/cli-helpers.js

@@ -39,14 +39,13 @@ export async function getPassword(passwordOption, allowCache = true) {
 }
 
 /**
- * Verify password against config
+ * Verify password against config (supports both legacy and new hash formats)
  * @param {string} password - Password to verify
  * @param {Object} config - Config object with passwordHash
  * @returns {boolean}
  */
 export function verifyPassword(password, config) {
-    const encryptor = new Encryptor(password);
-    return encryptor.getPasswordHash() === config.passwordHash;
+    return Encryptor.verifyPasswordHash(password, config.passwordHash);
 }
 
 /**
@@ -62,11 +61,13 @@ export function validateConfig(config) {
         return { valid: false, errors };
     }
 
-    if (!config.botToken || typeof config.botToken !== 'string') {
-        errors.push('Missing or invalid botToken');
+    // v2: encrypted token, v1: plaintext token
+    const hasToken = config.encryptedBotToken || config.botToken;
+    if (!hasToken) {
+        errors.push('Missing bot token (botToken or encryptedBotToken)');
     }
 
-    if (!config.botToken?.includes(':')) {
+    if (config.botToken && !config.botToken.includes(':')) {
         errors.push('Invalid bot token format (should contain :)');
     }
 
@@ -84,6 +85,29 @@ export function validateConfig(config) {
     };
 }
 
+/**
+ * Decrypt bot token from config using password
+ * Supports both v1 (plaintext) and v2 (encrypted) configs
+ * @param {Object} config - Config object
+ * @param {string} password - User's password
+ * @returns {string} - Decrypted bot token
+ */
+export function decryptBotToken(config, password) {
+    // v1: plaintext token (backward compatibility)
+    if (config.botToken) {
+        return config.botToken;
+    }
+
+    // v2: encrypted token
+    if (config.encryptedBotToken) {
+        const encryptor = new Encryptor(password);
+        const encryptedBuffer = Buffer.from(config.encryptedBotToken, 'base64');
+        return encryptor.decrypt(encryptedBuffer).toString('utf-8');
+    }
+
+    throw new Error('No bot token found in config');
+}
+
 /**
  * Load and validate config
  * @param {string} dataDir - Data directory path
@@ -143,3 +167,17 @@ export async function getAndVerifyPassword(passwordOption, dataDir) {
 
     return password;
 }
+
+/**
+ * Resolve config by decrypting bot token if needed.
+ * Returns a config object with a guaranteed plaintext `botToken` field.
+ * @param {Object} config - Raw config from disk
+ * @param {string} password - Verified password
+ * @returns {Object} - Config with decrypted botToken
+ */
+export function resolveConfig(config, password) {
+    return {
+        ...config,
+        botToken: decryptBotToken(config, password)
+    };
+}

package/src/utils/download-stream.js

@@ -0,0 +1,87 @@
+/**
+ * Shared download pipeline — Telegram → Decrypt → Decompress
+ *
+ * Eliminates the triplicated download-stream pattern across
+ * index.js, share/server.js, and fuse/mount.js.
+ */
+
+import { Readable } from 'stream';
+import { pipeline } from 'stream/promises';
+import { parseHeader, HEADER_SIZE } from './chunker.js';
+
+/**
+ * Create the download pipeline streams for a file stored in Telegram.
+ *
+ * @param {object} options
+ * @param {object} options.client     – TelegramClient instance (initialized, with chatId set)
+ * @param {Array}  options.chunks     – Chunk records from DB, each with { chunk_index, file_telegram_id, size }
+ * @param {object} options.encryptor  – Encryptor instance
+ * @param {object} options.compressor – Compressor instance
+ * @param {function} [options.onChunkDownloaded] – Optional callback({ chunkIndex, totalChunks, bytesDownloaded, totalBytes })
+ * @returns {Promise<{ readable: Readable, header: object }>}
+ *   readable: a stream of decrypted (and decompressed) file content
+ *   header: parsed WAS1 header from the first chunk
+ */
+export async function createDownloadPipeline({ client, chunks, encryptor, compressor, onChunkDownloaded }) {
+    if (chunks.length === 0) throw new Error('No chunks found');
+
+    // Sort by chunk_index
+    const sortedChunks = [...chunks].sort((a, b) => a.chunk_index - b.chunk_index);
+
+    // Download the first chunk to inspect the header
+    const firstChunkData = await client.downloadFile(sortedChunks[0].file_telegram_id);
+    const header = parseHeader(firstChunkData);
+
+    const decryptStream = encryptor.getDecryptStream();
+    const decompressStream = compressor.getDecompressStream(header.compressed);
+
+    const totalBytes = sortedChunks.reduce((acc, c) => acc + (c.size || 0), 0);
+    let bytesDownloaded = 0;
+    let currentIndex = 0;
+    let preloadedFirst = firstChunkData;
+
+    const telegramStream = new Readable({
+        async read() {
+            try {
+                if (currentIndex >= sortedChunks.length) {
+                    this.push(null);
+                    return;
+                }
+
+                let data;
+                if (currentIndex === 0 && preloadedFirst) {
+                    data = preloadedFirst;
+                    preloadedFirst = null;
+                } else {
+                    data = await client.downloadFile(sortedChunks[currentIndex].file_telegram_id);
+                }
+
+                bytesDownloaded += data.length;
+                onChunkDownloaded?.({
+                    chunkIndex: currentIndex,
+                    totalChunks: sortedChunks.length,
+                    bytesDownloaded,
+                    totalBytes
+                });
+
+                // Strip the WAS1 header before pushing into the decrypt pipeline
+                this.push(data.subarray(HEADER_SIZE));
+                currentIndex++;
+            } catch (err) {
+                this.destroy(err);
+            }
+        }
+    });
+
+    // Wire the internal pipeline: telegram → decrypt → decompress
+    // We use a PassThrough as the readable end so callers can pipe/pipeline it freely.
+    const { PassThrough } = await import('stream');
+    const output = new PassThrough();
+
+    // Run the internal pipeline in the background; errors propagate through the output stream.
+    pipeline(telegramStream, decryptStream, decompressStream, output).catch((err) => {
+        if (!output.destroyed) output.destroy(err);
+    });
+
+    return { readable: output, header };
+}

package/src/utils/progress.js

@@ -76,10 +76,10 @@ export class ProgressBar {
      * Format bytes to human readable
      */
     formatBytes(bytes) {
-        if (bytes === 0) return '0 B';
+        if (!Number.isFinite(bytes) || bytes <= 0) return '0 B';
         const k = 1024;
-        const sizes = ['B', 'KB', 'MB', 'GB'];
-        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+        const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
         return (bytes / Math.pow(k, i)).toFixed(1) + ' ' + sizes[i];
     }