@ayush24k/telezipper 1.4.0 → 1.5.1

package/README.md

@@ -44,106 +44,66 @@ Example:
 telezipper ./my-folder -o ./output
 ```
 
-### With Password Protection
+### Chunking + Upload to Telegram (MTProto)
+This tool now uses **MTProto** (the Telegram Client Protocol) to support **large file uploads (up to 2GB)** and faster speeds. 
 
-```bash
-telezipper <source> -p <password> -o <output-directory>
-```
-
-Example:
-```bash
-telezipper ./my-folder -p MySecurePassword123 -o ./output
-```
-
-### With Telegram Upload
+To use it, you need a `TELEGRAM_API_ID` and `TELEGRAM_API_HASH`. You can get these from [my.telegram.org](https://my.telegram.org).
 
-You can provide Telegram credentials in two ways:
+You can pass them as arguments or set them in a `.env` file.
 
-#### Option 1: Command-line arguments (Recommended for flexibility)
+### Usage Examples
 
+#### 1. Basic Zip (No Password, No Telegram)
 ```bash
-telezipper <source> --telegram --bot-token YOUR_BOT_TOKEN --chat-id YOUR_CHAT_ID
+telezipper ./my-folder
+# Output: ./output/chunk_1.zip
 ```
 
-Example:
+#### 2. Zip with Password
 ```bash
-telezipper ./my-folder --telegram --bot-token 123456:ABC-DEF1234ghIkl --chat-id 987654321
+telezipper ./my-folder -p "secret123"
+# Output: Encrypted zip files in ./output
 ```
 
-#### Option 2: Environment variables
-
-Create a `.env` file in the project directory or set environment variables:
+#### 3. Zip + Upload to Telegram (Env Vars Set)
+Assuming `.env` has credentials:
+```bash
+telezipper ./my-folder --telegram
+```
 
+#### 4. Zip + Upload to Telegram (CLI Args)
 ```bash
-TELEGRAM_BOT_TOKEN=your_bot_token_here
-TELEGRAM_CHAT_ID=your_chat_id_here
+telezipper ./my-folder --telegram --api-id 12345 --api-hash abcdef123 --chat-id -100123456789
 ```
 
-Then run:
+#### 5. Password Protected Upload
 ```bash
-telezipper ./my-folder --telegram
+telezipper ./my-folder --telegram -p "mypassword"
 ```
 
+### Logging In
+- **User Login**: The tool will ask for your phone number and login code interactively. This session is saved locally in `.telegram_session`.
+
 ## Options
 
 - `<source>` - File or folder to zip (required)
 - `-o, --output <dir>` - Output directory (default: "output")
 - `-p, --password <password>` - Password to protect zip files (optional)
 - `--telegram` - Upload zip files to Telegram
-- `--bot-token <token>` - Telegram bot token (required if using --telegram without env vars)
-- `--chat-id <id>` - Telegram chat ID (required if using --telegram without env vars)
+- `--api-id <id>` - Telegram API ID (required for MTProto)
+- `--api-hash <hash>` - Telegram API Hash (required for MTProto)
+- `--chat-id <id>` - Chat ID to upload to (User ID or Channel/Group ID)
 - `-h, --help` - Display help
 
-## Examples
-
-### Zip a folder to the default output directory
-```bash
-telezipper ./my-project
-```
-
-### Zip and specify custom output directory
-```bash
-telezipper ./my-project -o ./backups
-```
-
-### Zip and upload to Telegram with inline credentials
-```bash
-telezipper ./my-project --telegram --bot-token 123456:ABC-DEF --chat-id 987654321
-```
-
-### Zip and upload using environment variables
-```bash
-# Set environment variables first
-export TELEGRAM_BOT_TOKEN=123456:ABC-DEF
-export TELEGRAM_CHAT_ID=987654321
-
-# Then run
-telezipper ./my-project --telegram
-```
-
-### Zip with password protection
-```bash
-telezipper ./my-project -p MySecurePassword123
-```
+## Features
 
-### Zip with password and upload to Telegram
-```bash
-telezipper ./my-project -p MySecurePassword123 --telegram --bot-token 123456:ABC-DEF --chat-id 987654321
-```
+- 🚀 **MTProto Support**: Uploads files >50MB (tested up to 2GB).
+- 🔐 **Encrypted Zips**: Optional AES-256 password protection.
+- ⚡ **Parallel Chunking**: Zips chunks in parallel for faster processing.
+- ⏯️ **Serial Uploads**: Uploads files one by one with a random delay (2-5s) to avoid flood limits.
+- 💾 **Smart Chunking**: Splits large folders into zip chunks (max 2GB each).
+- ✅ **MTProto Auth**: Support for User accounts with session persistence.
 
 ## How to Get Telegram Credentials
-
-1. **Bot Token**: Create a bot using [@BotFather](https://t.me/botfather) on Telegram
-2. **Chat ID**: 
-   - Send a message to your bot
-   - Visit `https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates`
-   - Find your chat ID in the response
-
-## Features
-
-- ✅ Automatically splits large folders into 50MB chunks
-- ✅ Creates zip files with maximum compression
-- ✅ Password protection with AES-256 encryption
-- ✅ Optional Telegram upload with progress bars
-- ✅ Works from any directory on your system
-- ✅ Flexible credential management (CLI args or env vars)
+1. **API ID & Hash**: Go to [my.telegram.org](https://my.telegram.org), log in, and click "API development tools". Create a new application to get your `App api_id` and `App api_hash`.
+2. **Chat ID**: You can get your Chat ID by forwarding a message to a bot like @userinfobot. For channels/groups, it usually starts with `-100`.

package/dist/bin/zipper.js

@@ -16,21 +16,23 @@ program
     .option("-o, --output <dir>", "Output directory", "output")
     .option("-p, --password <password>", "Password to protect zip files")
     .option("--telegram", "Upload zip files to Telegram")
-    .option("--bot-token <token>", "Telegram bot token (required if using --telegram)")
+    .option("--api-id <id>", "Telegram API ID (required for MTProto)")
+    .option("--api-hash <hash>", "Telegram API Hash (required for MTProto)")
     .option("--chat-id <id>", "Telegram chat ID (required if using --telegram)")
     .parse();
 (async () => {
     const source = path_1.default.resolve(program.args[0]);
     const outputDir = path_1.default.resolve(program.opts().output);
     const useTelegram = program.opts().telegram || false;
-    const botToken = program.opts().botToken;
     const chatId = program.opts().chatId;
     const password = program.opts().password;
+    const apiId = program.opts().apiId;
+    const apiHash = program.opts().apiHash;
     console.log(`\n🕸️  Crawling files in ${source}...`);
     const files = await (0, crawler_1.crawl)(source);
     console.log(`📂 Found ${files.length} file${files.length !== 1 ? 's' : ''}`);
     const chunks = (0, chunking_1.chunkFiles)(files);
-    console.log(`📦 Created ${chunks.length} chunk${chunks.length !== 1 ? 's' : ''} (max 48MB each)${password ? ' 🔒 Password protected' : ''}\n`);
-    await (0, zipper_1.zipChunks)(chunks, outputDir, useTelegram, botToken, chatId, password);
+    console.log(`📦 Created ${chunks.length} chunk${chunks.length !== 1 ? 's' : ''} (max 2GB each)${password ? ' 🔒 Password protected' : ''}\n`);
+    await (0, zipper_1.zipChunks)(chunks, outputDir, useTelegram, chatId, password, apiId, apiHash);
     console.log(`\n🎉 All done! ${useTelegram ? 'Files uploaded to Telegram.' : `Zips saved to ${outputDir}`}`);
 })();

package/dist/src/chunking.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chunkFiles = chunkFiles;
-const CHUNK_SIZE = 48 * 1024 * 1024; // 48 MB
+const CHUNK_SIZE = 1.9 * 1024 * 1024 * 1024; // 1.9 GB
 // groups files into chunks where the total size of each chunk does not exceed CHUNK_SIZE
 function chunkFiles(files) {
     const chunks = [];
@@ -9,7 +9,7 @@ function chunkFiles(files) {
     let currentChunkSize = 0;
     for (const file of files) {
         if (file.size > CHUNK_SIZE) {
-            console.warn(`⚠️ Skipping file ${file.path} as it exceeds the maximum size of 48MB (${(file.size / (1024 * 1024)).toFixed(2)} MB).`);
+            console.warn(`⚠️ Skipping file ${file.path} as it exceeds the maximum size of 1.9GB (${(file.size / (1024 * 1024 * 1024)).toFixed(2)} GB).`);
             continue;
         }
         if (currentChunkSize + file.size > CHUNK_SIZE) {

package/dist/src/telegramUploader.js

@@ -3,36 +3,74 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTelegramClient = initTelegramClient;
 exports.uploadToTelegram = uploadToTelegram;
-const node_telegram_bot_api_1 = __importDefault(require("node-telegram-bot-api"));
+const telegram_1 = require("telegram");
+const sessions_1 = require("telegram/sessions");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const cli_progress_1 = __importDefault(require("cli-progress"));
-// Suppress the polling deprecation warning
-process.env.NTBA_FIX_350 = "1";
-// upload a zip file to telegram with progress bar
-async function uploadToTelegram(zipPath, botToken, chatId) {
-    const bot_token = botToken || process.env.TELEGRAM_BOT_TOKEN || "";
-    const chat_id = chatId || process.env.TELEGRAM_CHAT_ID || "";
-    if (!bot_token || !chat_id) {
-        throw new Error("❌ Telegram credentials are missing. Please provide --bot-token and --chat-id or set TELEGRAM_BOT_TOKEN and TELEGRAM_CHAT_ID environment variables.");
+const input_1 = __importDefault(require("input"));
+let client = null;
+const sessionPath = path_1.default.join(process.cwd(), ".telegram_session");
+async function initTelegramClient(apiId, apiHash) {
+    const API_ID = Number(apiId || process.env.TELEGRAM_API_ID);
+    const API_HASH = apiHash || process.env.TELEGRAM_API_HASH;
+    if (!API_ID || !API_HASH) {
+        throw new Error("❌ Telegram API_ID and API_HASH are required for MTProto. Please set them in .env or provide as arguments.");
+    }
+    let sessionString = "";
+    if (fs_1.default.existsSync(sessionPath)) {
+        sessionString = fs_1.default.readFileSync(sessionPath, "utf-8");
+    }
+    const stringSession = new sessions_1.StringSession(sessionString);
+    client = new telegram_1.TelegramClient(stringSession, API_ID, API_HASH, {
+        connectionRetries: 5,
+    });
+    await client.start({
+        phoneNumber: async () => await input_1.default.text("Please enter your number: "),
+        password: async () => await input_1.default.text("Please enter your password: "),
+        phoneCode: async () => await input_1.default.text("Please enter the code you received: "),
+        onError: (err) => console.log(err),
+    });
+    // Save session
+    fs_1.default.writeFileSync(sessionPath, client.session.save());
+    console.log("✅ Connected to Telegram via MTProto!");
+}
+async function uploadToTelegram(zipPath, chatId) {
+    if (!client) {
+        throw new Error("❌ Telegram client not initialized.");
+    }
+    const chat_id = chatId || process.env.TELEGRAM_CHAT_ID;
+    if (!chat_id) {
+        throw new Error("❌ Chat ID is missing.");
     }
-    const bot = new node_telegram_bot_api_1.default(bot_token, { polling: false });
-    const totalSize = fs_1.default.statSync(zipPath).size;
     const fileName = path_1.default.basename(zipPath);
+    const totalSize = fs_1.default.statSync(zipPath).size;
     const fileSizeMB = (totalSize / (1024 * 1024)).toFixed(2);
     console.log(`\n📤 Uploading ${fileName} (${fileSizeMB} MB)`);
     const progressBar = new cli_progress_1.default.SingleBar({
         format: "Uploading [{bar}] {percentage}% | {value}/{total} Bytes",
     }, cli_progress_1.default.Presets.shades_classic);
     progressBar.start(totalSize, 0);
-    const stream = fs_1.default.createReadStream(zipPath);
-    let uploaded = 0;
-    stream.on("data", (chunk) => {
-        uploaded += chunk.length;
-        progressBar.update(uploaded);
-    });
-    await bot.sendDocument(chat_id, stream);
-    progressBar.stop();
-    console.log(`✅ ${fileName} uploaded successfully`);
+    try {
+        await client.sendFile(chat_id, {
+            file: zipPath,
+            forceDocument: true,
+            progressCallback: (progress) => {
+                // progress is 0 to 1 (float)
+                // We need to map it to bytes for the progress bar, but GramJS progress is sometimes tricky.
+                // Assuming it's ratio.
+                progressBar.update(Math.floor(progress * totalSize));
+            }
+        });
+        progressBar.update(totalSize); // Ensure it finishes
+        progressBar.stop();
+        console.log(`✅ ${fileName} uploaded successfully`);
+    }
+    catch (error) {
+        progressBar.stop();
+        console.error(`❌ Failed to upload ${fileName}:`, error);
+        throw error;
+    }
 }

package/dist/src/zipper.js

@@ -13,17 +13,31 @@ const archiver_zip_encrypted_1 = __importDefault(require("archiver-zip-encrypted
 const telegramUploader_1 = require("./telegramUploader");
 // Register the encrypted format
 archiver_1.default.registerFormat('zip-encrypted', archiver_zip_encrypted_1.default);
-async function zipChunks(chunks, outputDir, useTelegram, botToken, chatId, password) {
+// Helper for serial execution
+let uploadQueue = Promise.resolve();
+const queueUpload = (action) => {
+    const next = uploadQueue.then(action).catch(err => {
+        console.error("Queue error:", err);
+        throw err;
+    });
+    uploadQueue = next.catch(() => { }); // Prevent queue from breaking on error, but we still throw for the caller
+    return next;
+};
+async function zipChunks(chunks, outputDir, useTelegram, chatId, password, apiId, apiHash) {
     fs_1.default.mkdirSync(outputDir, { recursive: true });
-    const uploadQueue = [];
-    for (let i = 0; i < chunks.length; i++) {
+    if (useTelegram) {
+        console.log("🔄 Initializing Telegram Client...");
+        await (0, telegramUploader_1.initTelegramClient)(apiId, apiHash);
+    }
+    // Process chunks in parallel (Zipping is parallel, Uploading is queued/serial)
+    await Promise.all(chunks.map(async (chunk, i) => {
         const zipName = `chunk_${i + 1}.zip`;
         const zipPath = path_1.default.join(outputDir, zipName);
-        console.log(`📦 Zipping ${zipName}...`);
+        console.log(`📦 Zipping ${zipName} (starting)...`);
         const progressBar = new cli_progress_1.default.SingleBar({
             format: `Zipping ${zipName} [{bar}] {percentage}% | {value}/{total} files`,
         }, cli_progress_1.default.Presets.shades_classic);
-        progressBar.start(chunks[i].length, 0);
+        progressBar.start(chunk.length, 0);
         await new Promise((resolve, reject) => {
             const output = fs_1.default.createWriteStream(zipPath);
             // Use encrypted archiver if password is provided
@@ -37,22 +51,28 @@ async function zipChunks(chunks, outputDir, useTelegram, botToken, chatId, passw
             archive.pipe(output);
             output.on("close", () => {
                 progressBar.stop();
-                if (useTelegram) {
-                    uploadQueue.push((0, telegramUploader_1.uploadToTelegram)(zipPath, botToken, chatId));
-                }
-                ;
+                console.log(`✅ Zipped ${zipName}`);
                 resolve();
             });
-            archive.on("error", reject);
-            chunks[i].forEach((file, index) => {
+            archive.on("error", (err) => {
+                progressBar.stop();
+                reject(err);
+            });
+            chunk.forEach((file) => {
                 archive.file(file.path, { name: path_1.default.basename(file.path) });
                 progressBar.increment();
             });
             archive.finalize();
         });
-    }
-    if (useTelegram) {
-        console.log("\n🚀 Uploading all files to Telegram...");
-        await Promise.all(uploadQueue);
-    }
+        if (useTelegram) {
+            // Queue the upload so it happens serially
+            await queueUpload(async () => {
+                // Random delay between 2 and 5 seconds
+                const delay = Math.floor(Math.random() * (5000 - 2000 + 1) + 2000);
+                console.log(`⏳ Waiting ${delay / 1000}s before uploading ${zipName}...`);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                await (0, telegramUploader_1.uploadToTelegram)(zipPath, chatId);
+            });
+        }
+    }));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ayush24k/telezipper",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "Split folders into multiple 50MB zip files with optional Telegram upload made for personal use.",
   "files": [
     "dist"
@@ -35,14 +35,14 @@
     "cli-progress": "^3.12.0",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
-    "node-telegram-bot-api": "^0.67.0",
+    "input": "^1.0.1",
+    "telegram": "^2.26.22",
     "tough-cookie": "^2.5.0"
   },
   "devDependencies": {
     "@types/archiver": "^7.0.0",
     "@types/cli-progress": "^3.11.6",
     "@types/node": "^25.1.0",
-    "@types/node-telegram-bot-api": "^0.64.13",
     "typescript": "^5.9.3"
   }
-}
+}