@nightowne/tas-cli 1.0.0 → 1.1.0

package/README.md

@@ -1,158 +1,128 @@
-# 📦 TAS - Use Telegram as Your Cloud Storage
+# TAS — Telegram as Storage
 
-> **Free. Encrypted. Unlimited.** Stop paying for cloud storage.
+A CLI tool that uses your Telegram bot as encrypted file storage. Files are compressed, encrypted locally, then uploaded to your private bot chat.
 
 ```
-████████╗ █████╗ ███████╗
-╚══██╔══╝██╔══██╗██╔════╝
-   ██║   ███████║███████╗
-   ██║   ██╔══██║╚════██║
-   ██║   ██║  ██║███████║
-   ╚═╝   ╚═╝  ╚═╝╚══════╝
+┌─────────────┐     ┌───────────────┐     ┌──────────────┐
+│   CLI       │────▶│  Compress &   │────▶│  Telegram    │
+│   FUSE      │     │  Encrypt      │     │  Bot API     │
+└─────────────┘     └───────────────┘     └──────────────┘
+       │                    │                     │
+       ▼                    ▼                     ▼
+┌─────────────┐     ┌───────────────┐     ┌──────────────┐
+│ SQLite Index│     │ 49MB Chunks   │     │ Private Chat │
+└─────────────┘     └───────────────┘     └──────────────┘
 ```
 
-I got tired of paying $10/month for cloud storage. So I built this.
+## Why TAS?
 
-**TAS turns your Telegram bot into unlimited cloud storage.** Files are encrypted with AES-256 before upload — not even Telegram can read them.
+| Feature | TAS | Session-based tools (e.g. teldrive) |
+|---------|:---:|:-----------------------------------:|
+| Account ban risk | **None** (Bot API) | High (session hijack detection) |
+| Encryption | AES-256-GCM | Usually none |
+| Dependencies | SQLite only | Rclone, external DB |
+| Setup complexity | 2 minutes | Docker + multiple services |
 
-The killer feature? **Mount it as a folder.** Drag and drop files like it's Google Drive, but it's actually your private Telegram chat.
+**Key differences:**
+- Uses **Bot API**, not session-based auth — Telegram can't ban your account
+- **Encryption by default** — files encrypted before leaving your machine
+- **Local-first** — SQLite index, no cloud dependencies
+- **FUSE mount** — use Telegram like a folder
 
----
+## Security Model
 
-## ⚡ TL;DR
+| Component | Implementation |
+|-----------|----------------|
+| Cipher | AES-256-GCM |
+| Key derivation | PBKDF2-SHA512, 100,000 iterations |
+| Salt | 32 bytes, random per file |
+| IV | 12 bytes, random per file |
+| Auth tag | 16 bytes (integrity) |
 
-```bash
-npm install -g @nightowne/tas-cli
-tas init
-tas mount ~/cloud
-# Now use ~/cloud like any folder. Files go to Telegram.
-```
-
----
+Your password never leaves your machine. Telegram stores encrypted blobs.
 
-## 🤔 Why?
+## Limitations
 
-| | TAS | Google Drive | Dropbox |
-|---|:---:|:---:|:---:|
-| **Price** | Free forever | $10/mo after 15GB | $12/mo after 2GB |
-| **Storage** | Unlimited | Limited | Limited |
-| **E2E Encrypted** | ✅ | ❌ | ❌ |
-| **Mounts as folder** | ✅ | ❌ | ❌ |
-| **Your data, your control** | ✅ | ❌ | ❌ |
+- **Not a backup** — Telegram can delete content without notice
+- **No versioning** — overwriting a file deletes the old version
+- **49MB chunks** — files split due to Bot API limits
+- **FUSE required** — mount feature needs `libfuse` on Linux/macOS
+- **Single user** — designed for personal use, not multi-tenant
 
----
+## Quick Start
 
-## 🚀 Quick Start
-
-### 1. Get a Telegram Bot (30 seconds)
-- Message [@BotFather](https://t.me/BotFather) on Telegram
-- Send `/newbot`, pick a name
-- Copy the token
-
-### 2. Install & Setup
 ```bash
-npm install -g tas-cli
+# Install
+npm install -g @nightowne/tas-cli
+
+# Setup (creates bot connection + encryption password)
 tas init
-# Paste token, set password, message your bot
-```
 
-### 3. Use It
-```bash
-# Upload files
+# Upload a file
 tas push secret.pdf
 
-# Mount as a folder (the magic ✨)
-tas mount ~/cloud
-cp anything.zip ~/cloud/      # uploads to Telegram
-open ~/cloud/secret.pdf       # downloads from Telegram
-```
-
----
-
-## � The Folder Thing
-
-This is the part that makes TAS different. Run `tas mount ~/cloud` and you get a folder that:
-
-- **Looks normal** in your file manager
-- **Drag & drop** = upload to Telegram
-- **Open files** = download from Telegram
-- **Delete files** = removes from Telegram
-
-It's like Dropbox, except free and you own your data.
-
-```bash
-$ ls ~/cloud
-secret.pdf  photos.zip  notes.txt
-
-$ cp newfile.doc ~/cloud/
-# Compresses → Encrypts → Uploads to Telegram
-```
-
----
+# Download a file
+tas pull secret.pdf
 
-## 🏷️ Organize with Tags
-
-```bash
-tas tag add report.pdf work finance
-tas tag list work           # shows all "work" files
-tas tag remove report.pdf finance
-```
-
----
-
-## 🔄 Auto-Sync Folders
-
-Dropbox-style sync. Any changes in the folder → auto-upload to Telegram.
-
-```bash
-tas sync add ~/Documents/work
-tas sync start
-# Now any file changes auto-sync to Telegram
-```
-
-Two-way sync:
-```bash
-tas sync pull    # Download everything from Telegram → local
+# Mount as folder (requires libfuse)
+tas mount ~/cloud
 ```
 
----
-
-## �️ Security
-
-- **AES-256-GCM** encryption
-- **PBKDF2** key derivation (100k iterations)
-- **Random IV** per file
-- Password never stored (only hash for verification)
-
-Your files are encrypted **before** they leave your computer. Telegram sees gibberish.
-
----
-
-## 📖 All Commands
+### Prerequisites
+- Node.js ≥18
+- Telegram account + bot token from [@BotFather](https://t.me/BotFather)
+- `libfuse` for mount feature:
+  ```bash
+  # Debian/Ubuntu
+  sudo apt install fuse libfuse-dev
+  
+  # Fedora
+  sudo dnf install fuse fuse-devel
+  
+  # macOS
+  brew install macfuse
+  ```
+
+## CLI Reference
 
 ```bash
-tas init                 # Setup
-tas push <file>          # Upload
-tas pull <file>          # Download
-tas list                 # List files
-tas delete <file>        # Remove
-tas mount <folder>       # 🔥 Mount as folder
-tas unmount <folder>     # Unmount
-tas tag add/remove/list  # Tags
-tas sync add/start/pull  # Folder sync
-tas verify               # Check file integrity
-tas status               # Stats
+# Core
+tas init                    # Setup wizard
+tas push <file>             # Upload file
+tas pull <file|hash>        # Download file
+tas list [-l]               # List files (long format)
+tas delete <file|hash>      # Remove file
+tas status                  # Show stats
+
+# Search & Resume (v1.1.0)
+tas search <query>          # Search by filename
+tas search -t <query>       # Search by tag
+tas resume                  # Resume interrupted uploads
+
+# FUSE Mount
+tas mount <path>            # Mount as folder
+tas unmount <path>          # Unmount
+
+# Tags
+tas tag add <file> <tags...>    # Add tags
+tas tag remove <file> <tags...> # Remove tags
+tas tag list [tag]              # List tags or files by tag
+
+# Sync (Dropbox-style)
+tas sync add <folder>       # Register folder for sync
+tas sync start              # Start watching
+tas sync pull               # Download all to sync folders
+tas sync status             # Show sync status
+
+# Verification
+tas verify                  # Check file integrity
 ```
 
----
-
-## ⚙️ Auto-Start on Boot
+## Auto-Start (systemd)
 
-Want sync running 24/7? Check out [systemd/README.md](systemd/README.md) for the setup.
+See [systemd/README.md](systemd/README.md) for running sync as a service.
 
----
-
-## 🧪 Development
+## Development
 
 ```bash
 git clone https://github.com/ixchio/tas
@@ -161,14 +131,19 @@ npm install
 npm test  # 28 tests
 ```
 
----
-
-## 📝 License
-
-MIT — do whatever you want.
-
----
+### Project Structure
+```
+src/
+├── cli.js           # Command definitions
+├── index.js         # Upload/download pipeline
+├── crypto/          # AES-256-GCM encryption
+├── db/              # SQLite file index
+├── fuse/            # FUSE filesystem mount
+├── sync/            # Folder sync engine
+├── telegram/        # Bot API client
+└── utils/           # Compression, chunking
+```
 
-**Made because cloud storage shouldn't cost money.** ☁️
+## License
 
-If this saved you some subscription fees, star the repo ⭐
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nightowne/tas-cli",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "📦 Telegram as Storage - Free encrypted cloud storage via Telegram. Mount Telegram as a folder!",
   "type": "module",
   "main": "src/index.js",
@@ -43,13 +43,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "node-telegram-bot-api": "^0.66.0",
+    "better-sqlite3": "^12.6.2",
+    "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "better-sqlite3": "^11.6.0",
     "fuse-native": "^2.2.6",
-    "ora": "^8.1.1",
-    "chalk": "^5.3.0",
-    "inquirer": "^12.2.0"
+    "inquirer": "^12.2.0",
+    "node-telegram-bot-api": "^0.66.0",
+    "ora": "^8.1.1"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/cli.js

@@ -179,16 +179,33 @@ program
 
             spinner.start('Processing file...');
 
+            // Import progress bar
+            const { ProgressBar } = await import('./utils/progress.js');
+            let progressBar = null;
+
             // Process and upload
             const result = await processFile(file, {
                 password,
                 dataDir: DATA_DIR,
                 customName: options.name,
                 config,
-                onProgress: (msg) => { spinner.text = msg; }
+                onProgress: (msg) => {
+                    if (!progressBar) spinner.text = msg;
+                },
+                onByteProgress: ({ uploaded, total }) => {
+                    if (!progressBar) {
+                        spinner.stop();
+                        progressBar = new ProgressBar({ label: 'Uploading', total });
+                    }
+                    progressBar.update(uploaded);
+                }
             });
 
-            spinner.succeed(`Uploaded: ${chalk.green(result.filename)}`);
+            if (progressBar) {
+                progressBar.complete(`Uploaded: ${result.filename}`);
+            } else {
+                spinner.succeed(`Uploaded: ${chalk.green(result.filename)}`);
+            }
             console.log(chalk.dim(`  Hash: ${result.hash}`));
             console.log(chalk.dim(`  Size: ${formatBytes(result.originalSize)} → ${formatBytes(result.storedSize)}`));
             console.log(chalk.dim(`  Chunks: ${result.chunks}`));
@@ -247,16 +264,33 @@ program
 
             spinner.start('Downloading...');
 
+            // Import progress bar
+            const { ProgressBar } = await import('./utils/progress.js');
+            let progressBar = null;
+
             const outputPath = options.output || fileRecord.filename;
             await retrieveFile(fileRecord, {
                 password,
                 dataDir: DATA_DIR,
                 outputPath,
                 config,
-                onProgress: (msg) => { spinner.text = msg; }
+                onProgress: (msg) => {
+                    if (!progressBar) spinner.text = msg;
+                },
+                onByteProgress: ({ downloaded, total }) => {
+                    if (!progressBar && total > 0) {
+                        spinner.stop();
+                        progressBar = new ProgressBar({ label: 'Downloading', total });
+                    }
+                    if (progressBar) progressBar.update(downloaded);
+                }
             });
 
-            spinner.succeed(`Downloaded: ${chalk.green(outputPath)}`);
+            if (progressBar) {
+                progressBar.complete(`Downloaded: ${outputPath}`);
+            } else {
+                spinner.succeed(`Downloaded: ${chalk.green(outputPath)}`);
+            }
 
         } catch (err) {
             spinner.fail(`Download failed: ${err.message}`);
@@ -1005,6 +1039,201 @@ function formatBytes(bytes) {
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 
+// ============== SEARCH COMMAND ==============
+program
+    .command('search <query>')
+    .description('Search files by name or tag')
+    .option('-t, --tag', 'Search by tag instead of filename')
+    .action(async (query, options) => {
+        try {
+            const db = new FileIndex(path.join(DATA_DIR, 'index.db'));
+            db.init();
+
+            const results = options.tag
+                ? db.searchByTag(query)
+                : db.search(query);
+
+            if (results.length === 0) {
+                console.log(chalk.yellow(`\n📭 No files found matching "${query}"\n`));
+                db.close();
+                return;
+            }
+
+            console.log(chalk.cyan(`\n🔍 Search Results for "${query}" (${results.length})\n`));
+
+            for (const file of results) {
+                const tags = file.tags ? chalk.dim(` [${file.tags}]`) : '';
+                console.log(`  ${chalk.blue('●')} ${file.filename} ${chalk.dim(`(${formatBytes(file.original_size)})`)}${tags}`);
+            }
+
+            console.log();
+            db.close();
+        } catch (err) {
+            console.error(chalk.red('Search failed:'), err.message);
+            process.exit(1);
+        }
+    });
+
+// ============== RESUME COMMAND ==============
+program
+    .command('resume')
+    .description('Resume interrupted uploads')
+    .action(async () => {
+        try {
+            const db = new FileIndex(path.join(DATA_DIR, 'index.db'));
+            db.init();
+
+            const pending = db.getPendingUploads();
+
+            if (pending.length === 0) {
+                console.log(chalk.yellow('\n📭 No interrupted uploads found.\n'));
+                db.close();
+                return;
+            }
+
+            console.log(chalk.cyan(`\n🔄 Pending Uploads (${pending.length})\n`));
+
+            for (const upload of pending) {
+                const progress = Math.round((upload.uploaded_chunks / upload.total_chunks) * 100);
+                console.log(`  ${chalk.blue('●')} ${upload.filename}`);
+                console.log(chalk.dim(`    Progress: ${upload.uploaded_chunks}/${upload.total_chunks} chunks (${progress}%)`));
+                console.log(chalk.dim(`    Started: ${new Date(upload.created_at).toLocaleString()}`));
+            }
+
+            console.log();
+
+            // Ask if user wants to resume
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: 'What would you like to do?',
+                    choices: [
+                        { name: 'Resume all pending uploads', value: 'resume' },
+                        { name: 'Clear all pending uploads', value: 'clear' },
+                        { name: 'Cancel', value: 'cancel' }
+                    ]
+                }
+            ]);
+
+            if (action === 'cancel') {
+                db.close();
+                return;
+            }
+
+            if (action === 'clear') {
+                for (const upload of pending) {
+                    // Clean up temp files
+                    const chunks = db.getPendingChunks(upload.id);
+                    for (const chunk of chunks) {
+                        try { fs.unlinkSync(chunk.chunk_path); } catch (e) { }
+                    }
+                    if (upload.temp_dir) {
+                        try { fs.rmdirSync(upload.temp_dir); } catch (e) { }
+                    }
+                    db.deletePendingUpload(upload.id);
+                }
+                console.log(chalk.green('✓ Cleared all pending uploads'));
+                db.close();
+                return;
+            }
+
+            // Resume uploads
+            const configPath = path.join(DATA_DIR, 'config.json');
+            if (!fs.existsSync(configPath)) {
+                console.log(chalk.red('✗ TAS not initialized.'));
+                db.close();
+                return;
+            }
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+            // Get password
+            const { password } = await inquirer.prompt([
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'Enter your encryption password:',
+                    mask: '*'
+                }
+            ]);
+
+            const encryptor = new Encryptor(password);
+            if (encryptor.getPasswordHash() !== config.passwordHash) {
+                console.log(chalk.red('✗ Incorrect password'));
+                db.close();
+                return;
+            }
+
+            // Connect to Telegram
+            const { TelegramClient } = await import('./telegram/client.js');
+            const client = new TelegramClient(DATA_DIR);
+            await client.initialize(config.botToken);
+            client.setChatId(config.chatId);
+
+            for (const upload of pending) {
+                console.log(chalk.cyan(`\n📤 Resuming: ${upload.filename}`));
+
+                const chunks = db.getPendingChunks(upload.id);
+                const pendingChunks = chunks.filter(c => !c.uploaded);
+
+                for (const chunk of pendingChunks) {
+                    if (!fs.existsSync(chunk.chunk_path)) {
+                        console.log(chalk.red(`  ✗ Chunk file missing: ${chunk.chunk_path}`));
+                        continue;
+                    }
+
+                    console.log(chalk.dim(`  ↑ Uploading chunk ${chunk.chunk_index + 1}/${upload.total_chunks}...`));
+
+                    const caption = upload.total_chunks > 1
+                        ? `📦 ${upload.filename} (${chunk.chunk_index + 1}/${upload.total_chunks})`
+                        : `📦 ${upload.filename}`;
+
+                    const result = await client.sendFile(chunk.chunk_path, caption);
+                    db.markChunkUploaded(upload.id, chunk.chunk_index, result.messageId.toString(), result.fileId);
+
+                    // Clean up temp file
+                    fs.unlinkSync(chunk.chunk_path);
+                }
+
+                // All chunks uploaded - finalize
+                const allChunks = db.getPendingChunks(upload.id);
+                if (allChunks.every(c => c.uploaded)) {
+                    // Add to main files table
+                    const fileId = db.addFile({
+                        filename: upload.filename,
+                        hash: upload.hash,
+                        originalSize: upload.original_size,
+                        storedSize: upload.original_size, // Approximate
+                        chunks: upload.total_chunks,
+                        compressed: true
+                    });
+
+                    // Add chunk records
+                    for (const chunk of allChunks) {
+                        db.addChunk(fileId, chunk.chunk_index, chunk.message_id, 0);
+                        db.db.prepare('UPDATE chunks SET file_telegram_id = ? WHERE file_id = ? AND chunk_index = ?')
+                            .run(chunk.file_telegram_id, fileId, chunk.chunk_index);
+                    }
+
+                    // Clean up pending record
+                    db.deletePendingUpload(upload.id);
+                    if (upload.temp_dir) {
+                        try { fs.rmdirSync(upload.temp_dir); } catch (e) { }
+                    }
+
+                    console.log(chalk.green(`  ✓ Completed: ${upload.filename}`));
+                }
+            }
+
+            console.log(chalk.green('\n✨ All uploads resumed!\n'));
+            db.close();
+
+        } catch (err) {
+            console.error(chalk.red('Resume failed:'), err.message);
+            process.exit(1);
+        }
+    });
+
 program.parse();
 
 

package/src/db/index.js

@@ -91,6 +91,34 @@ export class FileIndex {
         UNIQUE(folder_id, relative_path)
       );
     `);
+
+    // Create pending_uploads table for resume functionality
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS pending_uploads (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        filename TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        hash TEXT NOT NULL,
+        original_size INTEGER NOT NULL,
+        total_chunks INTEGER NOT NULL,
+        uploaded_chunks INTEGER NOT NULL DEFAULT 0,
+        temp_dir TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        UNIQUE(hash)
+      );
+
+      CREATE TABLE IF NOT EXISTS pending_chunks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        pending_id INTEGER NOT NULL,
+        chunk_index INTEGER NOT NULL,
+        chunk_path TEXT NOT NULL,
+        uploaded INTEGER NOT NULL DEFAULT 0,
+        message_id TEXT,
+        file_telegram_id TEXT,
+        FOREIGN KEY (pending_id) REFERENCES pending_uploads(id) ON DELETE CASCADE,
+        UNIQUE(pending_id, chunk_index)
+      );
+    `);
   }
 
   /**
@@ -345,6 +373,125 @@ export class FileIndex {
     stmt.run(folderId, relativePath);
   }
 
+  // ============== SEARCH METHODS ==============
+
+  /**
+   * Search files by filename (fuzzy match)
+   */
+  search(query) {
+    const stmt = this.db.prepare(`
+      SELECT f.*, GROUP_CONCAT(t.tag) as tags
+      FROM files f
+      LEFT JOIN tags t ON f.id = t.file_id
+      WHERE f.filename LIKE ?
+      GROUP BY f.id
+      ORDER BY f.created_at DESC
+    `);
+    return stmt.all(`%${query}%`);
+  }
+
+  /**
+   * Search files by tag
+   */
+  searchByTag(query) {
+    const stmt = this.db.prepare(`
+      SELECT f.*, GROUP_CONCAT(t.tag) as tags
+      FROM files f
+      INNER JOIN tags t ON f.id = t.file_id
+      WHERE t.tag LIKE ?
+      GROUP BY f.id
+      ORDER BY f.created_at DESC
+    `);
+    return stmt.all(`%${query}%`);
+  }
+
+  // ============== RESUME UPLOAD METHODS ==============
+
+  /**
+   * Add a pending upload
+   */
+  addPendingUpload(data) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO pending_uploads 
+      (filename, file_path, hash, original_size, total_chunks, uploaded_chunks, temp_dir)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      data.filename,
+      data.filePath,
+      data.hash,
+      data.originalSize,
+      data.totalChunks,
+      data.uploadedChunks || 0,
+      data.tempDir
+    );
+    return result.lastInsertRowid;
+  }
+
+  /**
+   * Add a pending chunk
+   */
+  addPendingChunk(pendingId, chunkIndex, chunkPath) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO pending_chunks (pending_id, chunk_index, chunk_path, uploaded)
+      VALUES (?, ?, ?, 0)
+    `);
+    stmt.run(pendingId, chunkIndex, chunkPath);
+  }
+
+  /**
+   * Mark chunk as uploaded
+   */
+  markChunkUploaded(pendingId, chunkIndex, messageId, fileTelegramId) {
+    const stmt = this.db.prepare(`
+      UPDATE pending_chunks 
+      SET uploaded = 1, message_id = ?, file_telegram_id = ?
+      WHERE pending_id = ? AND chunk_index = ?
+    `);
+    stmt.run(messageId, fileTelegramId, pendingId, chunkIndex);
+
+    // Update uploaded count
+    this.db.prepare(`
+      UPDATE pending_uploads SET uploaded_chunks = uploaded_chunks + 1 WHERE id = ?
+    `).run(pendingId);
+  }
+
+  /**
+   * Get all pending uploads
+   */
+  getPendingUploads() {
+    const stmt = this.db.prepare(`
+      SELECT * FROM pending_uploads ORDER BY created_at DESC
+    `);
+    return stmt.all();
+  }
+
+  /**
+   * Get pending chunks for an upload
+   */
+  getPendingChunks(pendingId) {
+    const stmt = this.db.prepare(`
+      SELECT * FROM pending_chunks WHERE pending_id = ? ORDER BY chunk_index
+    `);
+    return stmt.all(pendingId);
+  }
+
+  /**
+   * Delete a pending upload (and its chunks via CASCADE)
+   */
+  deletePendingUpload(pendingId) {
+    const stmt = this.db.prepare('DELETE FROM pending_uploads WHERE id = ?');
+    stmt.run(pendingId);
+  }
+
+  /**
+   * Get pending upload by hash
+   */
+  getPendingByHash(hash) {
+    const stmt = this.db.prepare('SELECT * FROM pending_uploads WHERE hash = ?');
+    return stmt.get(hash);
+  }
+
   /**
    * Close database connection
    */

package/src/index.js

@@ -19,7 +19,7 @@ const TELEGRAM_CHUNK_SIZE = 49 * 1024 * 1024;
  * Process and upload a file to Telegram
  */
 export async function processFile(filePath, options) {
-    const { password, dataDir, customName, config, onProgress } = options;
+    const { password, dataDir, customName, config, onProgress, onByteProgress } = options;
 
     onProgress?.('Reading file...');
 
@@ -109,6 +109,9 @@ export async function processFile(filePath, options) {
         compressed
     });
 
+    let uploadedBytes = 0;
+    const totalBytes = chunkFiles.reduce((acc, c) => acc + c.size, 0);
+
     for (const chunk of chunkFiles) {
         onProgress?.(`Uploading chunk ${chunk.index + 1}/${chunkFiles.length}...`);
 
@@ -118,6 +121,9 @@ export async function processFile(filePath, options) {
 
         const result = await client.sendFile(chunk.path, caption);
 
+        uploadedBytes += chunk.size;
+        onByteProgress?.({ uploaded: uploadedBytes, total: totalBytes, chunk: chunk.index + 1, totalChunks: chunkFiles.length });
+
         // Store file_id instead of message_id for downloads
         db.addChunk(fileId, chunk.index, result.messageId.toString(), chunk.size);
 
@@ -152,7 +158,7 @@ export async function processFile(filePath, options) {
  * Retrieve a file from Telegram
  */
 export async function retrieveFile(fileRecord, options) {
-    const { password, dataDir, outputPath, config, onProgress } = options;
+    const { password, dataDir, outputPath, config, onProgress, onByteProgress } = options;
 
     onProgress?.('Connecting to Telegram...');
 
@@ -174,11 +180,15 @@ export async function retrieveFile(fileRecord, options) {
 
     // Download all chunks
     const downloadedChunks = [];
+    let downloadedBytes = 0;
+    const totalBytes = fileRecord.stored_size || chunks.reduce((acc, c) => acc + (c.size || 0), 0);
 
     for (const chunk of chunks) {
         onProgress?.(`Downloading chunk ${chunk.chunk_index + 1}/${chunks.length}...`);
 
         const data = await client.downloadFile(chunk.file_telegram_id);
+        downloadedBytes += data.length;
+        onByteProgress?.({ downloaded: downloadedBytes, total: totalBytes, chunk: chunk.chunk_index + 1, totalChunks: chunks.length });
 
         // Parse header
         const header = parseHeader(data);

package/src/utils/progress.js

@@ -0,0 +1,119 @@
+/**
+ * Progress bar utility with speed calculation
+ * Shows actual MB/s instead of boring spinners
+ */
+
+import chalk from 'chalk';
+
+export class ProgressBar {
+    constructor(options = {}) {
+        this.total = options.total || 100;
+        this.width = options.width || 30;
+        this.label = options.label || 'Progress';
+        this.current = 0;
+        this.startTime = Date.now();
+        this.lastUpdate = 0;
+        this.lastBytes = 0;
+        this.speed = 0;
+    }
+
+    /**
+     * Update progress
+     * @param {number} current - Current bytes processed
+     */
+    update(current) {
+        this.current = current;
+
+        const now = Date.now();
+        const elapsed = now - this.lastUpdate;
+
+        // Calculate speed every 200ms
+        if (elapsed >= 200) {
+            const bytesDelta = current - this.lastBytes;
+            this.speed = (bytesDelta / elapsed) * 1000; // bytes per second
+            this.lastUpdate = now;
+            this.lastBytes = current;
+        }
+
+        this.render();
+    }
+
+    /**
+     * Render the progress bar
+     */
+    render() {
+        const percent = Math.min(100, Math.round((this.current / this.total) * 100));
+        const filled = Math.round((percent / 100) * this.width);
+        const empty = this.width - filled;
+
+        const bar = chalk.cyan('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+        const speedStr = this.formatSpeed(this.speed);
+        const sizeStr = `${this.formatBytes(this.current)}/${this.formatBytes(this.total)}`;
+
+        // Calculate ETA
+        const eta = this.speed > 0
+            ? Math.round((this.total - this.current) / this.speed)
+            : 0;
+        const etaStr = eta > 0 ? this.formatTime(eta) : '--:--';
+
+        // Clear line and write
+        process.stdout.write(`\r${this.label} ${bar} ${percent}% | ${sizeStr} | ${speedStr} | ETA: ${etaStr}  `);
+    }
+
+    /**
+     * Complete the progress bar
+     */
+    complete(message) {
+        const totalTime = (Date.now() - this.startTime) / 1000;
+        const avgSpeed = this.total / totalTime;
+
+        process.stdout.write('\r' + ' '.repeat(100) + '\r'); // Clear line
+        console.log(chalk.green(`✓ ${message || this.label}`) +
+            chalk.dim(` (${this.formatBytes(this.total)} in ${totalTime.toFixed(1)}s, avg ${this.formatSpeed(avgSpeed)})`));
+    }
+
+    /**
+     * Format bytes to human readable
+     */
+    formatBytes(bytes) {
+        if (bytes === 0) return '0 B';
+        const k = 1024;
+        const sizes = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return (bytes / Math.pow(k, i)).toFixed(1) + ' ' + sizes[i];
+    }
+
+    /**
+     * Format speed to human readable
+     */
+    formatSpeed(bytesPerSec) {
+        if (bytesPerSec === 0) return '-- MB/s';
+        const mbps = bytesPerSec / (1024 * 1024);
+        if (mbps >= 1) {
+            return mbps.toFixed(1) + ' MB/s';
+        }
+        const kbps = bytesPerSec / 1024;
+        return kbps.toFixed(0) + ' KB/s';
+    }
+
+    /**
+     * Format seconds to mm:ss
+     */
+    formatTime(seconds) {
+        const mins = Math.floor(seconds / 60);
+        const secs = seconds % 60;
+        return `${mins}:${secs.toString().padStart(2, '0')}`;
+    }
+}
+
+/**
+ * Create a simple progress callback for ora-style usage
+ */
+export function createProgressCallback(label, total) {
+    const bar = new ProgressBar({ label, total });
+    return {
+        update: (current) => bar.update(current),
+        complete: (msg) => bar.complete(msg),
+        bar
+    };
+}