@nightowne/tas-cli 2.0.0 → 2.1.0

package/src/telegram/client.js

@@ -6,6 +6,7 @@
 import TelegramBot from 'node-telegram-bot-api';
 import fs from 'fs';
 import path from 'path';
+import { pipeline } from 'stream/promises';
 
 export class TelegramClient {
     constructor(dataDir) {
@@ -18,8 +19,12 @@ export class TelegramClient {
      * Initialize with bot token
      * Get token from @BotFather on Telegram
      */
-    async initialize(token) {
-        this.bot = new TelegramBot(token, { polling: false });
+    async initialize(token, customApiUrl = null) {
+        const options = { polling: false };
+        if (customApiUrl) {
+            options.baseApiUrl = customApiUrl;
+        }
+        this.bot = new TelegramBot(token, options);
 
         // Verify the token works
         try {
@@ -75,30 +80,43 @@ export class TelegramClient {
      * Send a file to the storage chat
      * Telegram supports up to 2GB for documents!
      */
-    async sendFile(filePath, caption = '') {
+    async sendFile(filePath, caption = '', options = {}) {
         if (!this.chatId) {
             throw new Error('Chat ID not set. Run init first.');
         }
 
-        const fileStream = fs.createReadStream(filePath);
-        const filename = path.basename(filePath);
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
 
-        const message = await this.bot.sendDocument(this.chatId, fileStream, {
-            caption: caption
-        }, {
-            filename: filename,
-            contentType: 'application/octet-stream'
-        });
+        try {
+            let fileStream = fs.createReadStream(filePath);
+            const filename = path.basename(filePath);
+
+            if (options.limitRate) {
+                const { Throttle } = await import('../utils/throttle.js');
+                fileStream = fileStream.pipe(new Throttle(options.limitRate));
+            }
+
+            const message = await this.bot.sendDocument(this.chatId, fileStream, {
+                caption: caption
+            }, {
+                filename: filename,
+                contentType: 'application/octet-stream'
+            });
 
-        return {
-            messageId: message.message_id,
-            fileId: message.document.file_id,
-            timestamp: message.date
-        };
+            return {
+                messageId: message.message_id,
+                fileId: message.document.file_id,
+                timestamp: message.date
+            };
+        } catch (err) {
+            throw new Error(`Failed to upload to Telegram: ${err.message}`);
+        }
     }
 
     /**
-     * Download a file from Telegram
+     * Download a file from Telegram (In-Memory buffer)
      */
     async downloadFile(fileId) {
         // Get file path from Telegram servers
@@ -116,6 +134,16 @@ export class TelegramClient {
         return Buffer.concat(chunks);
     }
 
+    /**
+     * Efficiently download a file from Telegram straight to disk
+     */
+    async downloadFileToPath(fileId, destPath) {
+        const fileStream = await this.bot.getFileStream(fileId);
+        const writeStream = fs.createWriteStream(destPath);
+        await pipeline(fileStream, writeStream);
+        return destPath;
+    }
+
     /**
      * Delete a message (optional cleanup)
      */

package/src/utils/chunker.js

@@ -91,7 +91,17 @@ export function createHeader(filename, originalSize, chunkIndex, totalChunks, fl
     offset += 2;
 
     // Filename length
-    const filenameBytes = Buffer.from(filename, 'utf-8').subarray(0, 42);
+    let filenameBytes = Buffer.from(filename, 'utf-8');
+    if (filenameBytes.length > 42) {
+        // We carefully truncate by chars instead of bytes to avoid splitting a UTF-8 character in half!
+        let truncated = filename;
+        while (Buffer.from(truncated, 'utf-8').length > 42) {
+            // Remove one character at a time from the end
+            truncated = truncated.slice(0, -1);
+        }
+        filenameBytes = Buffer.from(truncated, 'utf-8');
+    }
+
     header.writeUInt16LE(filenameBytes.length, offset);
     offset += 2;
 

package/src/utils/compression.js

@@ -8,6 +8,7 @@ import path from 'path';
 
 const gzip = promisify(zlib.gzip);
 const gunzip = promisify(zlib.gunzip);
+import { PassThrough } from 'stream';
 
 // File extensions that are already compressed (skip compression for these)
 const SKIP_COMPRESSION = new Set([
@@ -71,6 +72,24 @@ export class Compressor {
         }
     }
 
+    /**
+     * Get a compression transform stream
+     * Returns: { stream: Transform, compressed: boolean }
+     */
+    getCompressStream(filename = '') {
+        if (this.shouldSkip(filename)) {
+            return {
+                stream: new PassThrough(),
+                compressed: false
+            };
+        }
+
+        return {
+            stream: zlib.createGzip({ level: 6 }),
+            compressed: true
+        };
+    }
+
     /**
      * Decompress gzip data
      */
@@ -81,4 +100,15 @@ export class Compressor {
 
         return await gunzip(data);
     }
+
+    /**
+     * Get a decompression transform stream
+     */
+    getDecompressStream(wasCompressed) {
+        if (!wasCompressed) {
+            return new PassThrough();
+        }
+
+        return zlib.createGunzip();
+    }
 }

package/src/utils/throttle.js

@@ -0,0 +1,26 @@
+import { Transform } from 'stream';
+
+export class Throttle extends Transform {
+    constructor(bytesPerSecond) {
+        super();
+        this.bytesPerSecond = bytesPerSecond;
+        this.passed = 0;
+        this.startTime = Date.now();
+    }
+
+    _transform(chunk, encoding, callback) {
+        this.passed += chunk.length;
+        const elapsed = Date.now() - this.startTime;
+        const expectedTime = (this.passed / this.bytesPerSecond) * 1000;
+
+        if (expectedTime > elapsed) {
+            setTimeout(() => {
+                this.push(chunk);
+                callback();
+            }, expectedTime - elapsed);
+        } else {
+            this.push(chunk);
+            callback();
+        }
+    }
+}