@nightowne/tas-cli 2.3.0 → 2.4.1

package/src/sync/sync.js

@@ -13,10 +13,6 @@ import { processFile } from '../index.js';
 // Debounce time in ms to batch rapid file changes
 const DEBOUNCE_MS = 1000;
 
-// Exponential backoff limits for upload errors
-const INITIAL_BACKOFF_MS = 2000;
-const MAX_BACKOFF_MS = 60000;
-
 // Ignore patterns
 const IGNORE_PATTERNS = [
     /^\./, // Hidden files
@@ -35,7 +31,6 @@ export class SyncEngine extends EventEmitter {
         this.config = options.config;
         this.limitRate = options.limitRate || null;
         this.watchers = new Map(); // path -> FSWatcher
-        this.rootWatchers = new Map(); // rootPath -> Set of watched subpaths (for Linux recursive watch fallback)
         this.pendingChanges = new Map(); // path -> timeout
         this.db = null;
         this.running = false;
@@ -110,8 +105,6 @@ export class SyncEngine extends EventEmitter {
         const promises = [];
 
         const worker = async () => {
-            let consecutiveErrors = 0;
-
             while (queue.length > 0) {
                 const file = queue.shift();
                 const existing = stateMap.get(file.relativePath);
@@ -148,7 +141,6 @@ export class SyncEngine extends EventEmitter {
                     // Update sync state
                     this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
                     uploaded++;
-                    consecutiveErrors = 0; // Reset on success
 
                     this.emit('file-upload-complete', { file: file.relativePath });
                 } catch (err) {
@@ -156,12 +148,9 @@ export class SyncEngine extends EventEmitter {
                     if (err.message.includes('duplicate')) {
                         this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
                         skipped++;
-                        consecutiveErrors = 0;
                     } else {
-                        consecutiveErrors++;
-                        // Exponential backoff: 2s → 4s → 8s → 16s → ... → 60s max
-                        const delay = Math.min(INITIAL_BACKOFF_MS * Math.pow(2, consecutiveErrors - 1), MAX_BACKOFF_MS);
-                        await new Promise(r => setTimeout(r, delay));
+                        // Sleep briefly on non-duplicate error (potential rate limits)
+                        await new Promise(r => setTimeout(r, 2000));
                         this.emit('file-upload-error', { file: file.relativePath, error: err.message });
                     }
                 }
@@ -249,148 +238,37 @@ export class SyncEngine extends EventEmitter {
         }
     }
 
-    /**
-     * Recursively list all subdirectories of a directory
-     */
-    getSubdirectories(dirPath) {
-        const subdirs = [];
-        try {
-            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    if (this.shouldIgnore(entry.name)) continue;
-                    const fullPath = path.join(dirPath, entry.name);
-                    subdirs.push(fullPath);
-                    subdirs.push(...this.getSubdirectories(fullPath));
-                }
-            }
-        } catch (err) {
-            // Ignore folder reading errors
-        }
-        return subdirs;
-    }
-
-    /**
-     * Watch a single directory (non-recursively) and dynamically watch new folders
-     */
-    watchSingleDir(rootPath, dir) {
-        if (this.watchers.has(dir)) return;
-
-        try {
-            const watcher = fs.watch(dir, { recursive: false }, (event, filename) => {
-                if (!filename) return;
-
-                const fullPath = path.join(dir, filename);
-                const relativePath = path.relative(rootPath, fullPath);
-
-                // If a new directory is created, watch it recursively
-                try {
-                    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
-                        if (!this.shouldIgnore(filename)) {
-                            this.watchDirRecursively(rootPath, fullPath);
-                        }
-                    }
-                } catch (e) {
-                    // Ignore stats errors
-                }
-
-                this.handleFileChange(rootPath, relativePath);
-            });
-
-            watcher.on('error', (err) => {
-                this.emit('watch-error', { folder: rootPath, error: err.message });
-            });
-
-            this.watchers.set(dir, watcher);
-
-            if (!this.rootWatchers.has(rootPath)) {
-                this.rootWatchers.set(rootPath, new Set());
-            }
-            this.rootWatchers.get(rootPath).add(dir);
-        } catch (err) {
-            this.emit('watch-error', { folder: rootPath, error: err.message });
-        }
-    }
-
-    /**
-     * Recursively watch a newly created directory and its subdirectories
-     */
-    watchDirRecursively(rootPath, dirPath) {
-        this.watchSingleDir(rootPath, dirPath);
-        const subdirs = this.getSubdirectories(dirPath);
-        for (const subdir of subdirs) {
-            this.watchSingleDir(rootPath, subdir);
-        }
-    }
-
     /**
      * Start watching a folder
      */
     watchFolder(folderPath) {
-        const isRecursiveSupported = process.platform === 'darwin' || process.platform === 'win32';
-
-        if (isRecursiveSupported) {
-            if (this.watchers.has(folderPath)) {
-                return; // Already watching
-            }
-
-            const watcher = fs.watch(folderPath, { recursive: true }, (event, filename) => {
-                if (filename) {
-                    this.handleFileChange(folderPath, filename);
-                }
-            });
-
-            watcher.on('error', (err) => {
-                this.emit('watch-error', { folder: folderPath, error: err.message });
-            });
+        if (this.watchers.has(folderPath)) {
+            return; // Already watching
+        }
 
-            this.watchers.set(folderPath, watcher);
-            this.emit('watch-start', { folder: folderPath });
-        } else {
-            // Manual recursive watch for Linux/other platforms
-            if (this.rootWatchers.has(folderPath)) {
-                return; // Already watching
+        const watcher = fs.watch(folderPath, { recursive: true }, (event, filename) => {
+            if (filename) {
+                this.handleFileChange(folderPath, filename);
             }
+        });
 
-            // Watch root
-            this.watchSingleDir(folderPath, folderPath);
+        watcher.on('error', (err) => {
+            this.emit('watch-error', { folder: folderPath, error: err.message });
+        });
 
-            // Watch all existing subdirectories
-            const subdirs = this.getSubdirectories(folderPath);
-            for (const subdir of subdirs) {
-                this.watchSingleDir(folderPath, subdir);
-            }
-
-            this.emit('watch-start', { folder: folderPath });
-        }
+        this.watchers.set(folderPath, watcher);
+        this.emit('watch-start', { folder: folderPath });
     }
 
     /**
      * Stop watching a folder
      */
     unwatchFolder(folderPath) {
-        const isRecursiveSupported = process.platform === 'darwin' || process.platform === 'win32';
-
-        if (isRecursiveSupported) {
-            const watcher = this.watchers.get(folderPath);
-            if (watcher) {
-                watcher.close();
-                this.watchers.delete(folderPath);
-                this.emit('watch-stop', { folder: folderPath });
-            }
-        } else {
-            if (this.rootWatchers.has(folderPath)) {
-                const dirs = this.rootWatchers.get(folderPath);
-                for (const dir of dirs) {
-                    const watcher = this.watchers.get(dir);
-                    if (watcher) {
-                        watcher.close();
-                        this.watchers.delete(dir);
-                    }
-                }
-                this.rootWatchers.delete(folderPath);
-                this.emit('watch-stop', { folder: folderPath });
-            }
+        const watcher = this.watchers.get(folderPath);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(folderPath);
+            this.emit('watch-stop', { folder: folderPath });
         }
     }
 
@@ -424,25 +302,11 @@ export class SyncEngine extends EventEmitter {
         this.pendingChanges.clear();
 
         // Close all watchers
-        const isRecursiveSupported = process.platform === 'darwin' || process.platform === 'win32';
-        if (isRecursiveSupported) {
-            for (const [folderPath, watcher] of this.watchers) {
-                watcher.close();
-                this.emit('watch-stop', { folder: folderPath });
-            }
-            this.watchers.clear();
-        } else {
-            for (const rootPath of this.rootWatchers.keys()) {
-                this.unwatchFolder(rootPath);
-            }
-            this.rootWatchers.clear();
-            
-            // Just in case, close any stray watchers
-            for (const watcher of this.watchers.values()) {
-                try { watcher.close(); } catch (e) {}
-            }
-            this.watchers.clear();
+        for (const [folderPath, watcher] of this.watchers) {
+            watcher.close();
+            this.emit('watch-stop', { folder: folderPath });
         }
+        this.watchers.clear();
 
         if (this.db) {
             this.db.close();

package/src/telegram/client.js

@@ -86,13 +86,16 @@ export class TelegramClient {
     async waitForChatId(timeout = 120000) {
         return new Promise((resolve, reject) => {
             const pollingBot = new TelegramBot(this.bot.token, { polling: true });
+            let isCompleted = false;
 
             const timer = setTimeout(() => {
+                isCompleted = true;
                 pollingBot.stopPolling();
                 reject(new Error('Timeout waiting for message. Please message your bot on Telegram.'));
             }, timeout);
 
             pollingBot.on('message', (msg) => {
+                isCompleted = true;
                 clearTimeout(timer);
                 pollingBot.stopPolling();
                 this.chatId = msg.chat.id;
@@ -104,10 +107,13 @@ export class TelegramClient {
             });
 
             pollingBot.on('polling_error', (err) => {
-                // Ignore polling errors during shutdown
-                if (!err.message.includes('ETELEGRAM')) {
-                    console.error('Polling error:', err.message);
+                // Only suppress errors after successful completion or during cleanup
+                // During active polling, log all errors for debugging
+                if (isCompleted && err.message.includes('ETELEGRAM')) {
+                    // Suppress expected cleanup errors
+                    return;
                 }
+                console.error('Polling error:', err.message);
             });
         });
     }

package/src/utils/branding.js

@@ -3,13 +3,6 @@
  */
 
 import chalk from 'chalk';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf-8'));
 
 export const LOGO = `
 ████████╗ █████╗ ███████╗
@@ -21,7 +14,7 @@ export const LOGO = `
 `;
 
 export const TAGLINE = 'Telegram as Storage';
-export const VERSION = pkg.version;
+export const VERSION = '2.4.1';
 
 /**
  * Print the TAS banner

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 };
+}