npm - @nightowne/tas-cli - Versions diffs - 1.1.1 → 2.1.0 - Mend

@nightowne/tas-cli 1.1.1 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md +102 -97
package/package.json +3 -3
package/src/cli.js +212 -147
package/src/crypto/encryption.js +128 -0
package/src/db/index.js +86 -0
package/src/fuse/mount.js +104 -40
package/src/index.js +173 -103
package/src/share/server.js +441 -0
package/src/sync/sync.js +54 -35
package/src/telegram/client.js +45 -17
package/src/utils/chunker.js +11 -1
package/src/utils/cli-helpers.js +145 -0
package/src/utils/compression.js +30 -0
package/src/utils/throttle.js +26 -0

package/src/share/server.js ADDED Viewed

@@ -0,0 +1,441 @@
+/**
+ * Share Server — Temporary file sharing via HTTP
+ * Spins up a lightweight server that serves one-time download links
+ * for files stored in Telegram. Files are decrypted on-the-fly.
+ */
+import http from 'http';
+import crypto from 'crypto';
+import path from 'path';
+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';
+/**
+ * Generate a secure random share token
+ */
+export function generateToken() {
+    return crypto.randomBytes(16).toString('hex');
+}
+/**
+ * Parse duration string to milliseconds
+ * Supports: 1h, 24h, 7d, 30m, etc.
+ */
+export function parseDuration(str) {
+    const match = str.match(/^(\d+)(m|h|d)$/);
+    if (!match) throw new Error(`Invalid duration: ${str}. Use format like 1h, 24h, 7d, 30m`);
+    const value = parseInt(match[1]);
+    const unit = match[2];
+    const multipliers = {
+        'm': 60 * 1000,
+        'h': 60 * 60 * 1000,
+        'd': 24 * 60 * 60 * 1000
+    };
+    return value * multipliers[unit];
+}
+/**
+ * Format remaining time human-readable
+ */
+function formatTimeLeft(expiresAt) {
+    const now = Date.now();
+    const diff = new Date(expiresAt).getTime() - now;
+    if (diff <= 0) return 'expired';
+    const hours = Math.floor(diff / (1000 * 60 * 60));
+    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
+    if (hours > 24) return `${Math.floor(hours / 24)}d ${hours % 24}h`;
+    if (hours > 0) return `${hours}h ${minutes}m`;
+    return `${minutes}m`;
+}
+/**
+ * Generate the download HTML page
+ */
+function generateDownloadPage(share, fileRecord) {
+    const timeLeft = formatTimeLeft(share.expires_at);
+    const downloadsLeft = share.max_downloads - share.download_count;
+    const fileSize = fileRecord.original_size;
+    const sizeStr = fileSize > 1048576
+        ? `${(fileSize / 1048576).toFixed(1)} MB`
+        : fileSize > 1024
+            ? `${(fileSize / 1024).toFixed(1)} KB`
+            : `${fileSize} B`;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TAS — Secure File Download</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0a0a0a;
+            color: #e0e0e0;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .card {
+            background: #1a1a2e;
+            border: 1px solid #2a2a4a;
+            border-radius: 16px;
+            padding: 40px;
+            max-width: 420px;
+            width: 90%;
+            text-align: center;
+            box-shadow: 0 20px 60px rgba(0,0,0,0.5);
+        }
+        .icon { font-size: 48px; margin-bottom: 16px; }
+        h1 { font-size: 20px; margin-bottom: 8px; color: #fff; }
+        .filename {
+            font-family: 'SF Mono', Monaco, monospace;
+            background: #0f0f23;
+            padding: 8px 16px;
+            border-radius: 8px;
+            margin: 16px 0;
+            font-size: 14px;
+            color: #7c83ff;
+            word-break: break-all;
+        }
+        .meta {
+            display: flex;
+            justify-content: center;
+            gap: 24px;
+            margin: 16px 0;
+            font-size: 13px;
+            color: #888;
+        }
+        .meta span { display: flex; align-items: center; gap: 4px; }
+        .btn {
+            display: inline-block;
+            background: linear-gradient(135deg, #667eea, #764ba2);
+            color: #fff;
+            text-decoration: none;
+            padding: 14px 40px;
+            border-radius: 10px;
+            font-size: 16px;
+            font-weight: 600;
+            margin-top: 20px;
+            transition: transform 0.2s, box-shadow 0.2s;
+        }
+        .btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 24px rgba(102, 126, 234, 0.3);
+        }
+        .footer {
+            margin-top: 24px;
+            font-size: 11px;
+            color: #555;
+        }
+        .footer a { color: #667eea; text-decoration: none; }
+    </style>
+</head>
+<body>
+    <div class="card">
+        <div class="icon">🔐</div>
+        <h1>Secure File Share</h1>
+        <div class="filename">${fileRecord.filename}</div>
+        <div class="meta">
+            <span>📦 ${sizeStr}</span>
+            <span>⏳ ${timeLeft}</span>
+            <span>⬇️ ${downloadsLeft} left</span>
+        </div>
+        <a href="/d/${share.token}?download=1" class="btn">⬇ Download</a>
+        <div class="footer">
+            Encrypted with AES-256-GCM · Powered by <a href="https://github.com/ixchio/tas">TAS</a>
+        </div>
+    </div>
+</body>
+</html>`;
+}
+/**
+ * Generate expired/invalid page
+ */
+function generateExpiredPage(reason = 'expired') {
+    const messages = {
+        expired: { icon: '⏰', title: 'Link Expired', desc: 'This download link has expired.' },
+        used: { icon: '✅', title: 'Already Downloaded', desc: 'This file has reached its download limit.' },
+        invalid: { icon: '❌', title: 'Invalid Link', desc: 'This download link is invalid or has been revoked.' }
+    };
+    const msg = messages[reason] || messages.invalid;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>TAS — ${msg.title}</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #0a0a0a;
+            color: #e0e0e0;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .card {
+            background: #1a1a2e;
+            border: 1px solid #2a2a4a;
+            border-radius: 16px;
+            padding: 40px;
+            max-width: 420px;
+            width: 90%;
+            text-align: center;
+        }
+        .icon { font-size: 48px; margin-bottom: 16px; }
+        h1 { font-size: 20px; margin-bottom: 8px; color: #fff; }
+        p { color: #888; font-size: 14px; }
+    </style>
+</head>
+<body>
+    <div class="card">
+        <div class="icon">${msg.icon}</div>
+        <h1>${msg.title}</h1>
+        <p>${msg.desc}</p>
+    </div>
+</body>
+</html>`;
+}
+export class ShareServer {
+    constructor(options) {
+        this.dataDir = options.dataDir;
+        this.password = options.password;
+        this.config = options.config;
+        this.port = options.port || 3000;
+        this.host = options.host || '0.0.0.0';
+        this.db = null;
+        this.client = null;
+        this.encryptor = null;
+        this.compressor = null;
+        this.server = null;
+    }
+    async initialize() {
+        this.db = new FileIndex(path.join(this.dataDir, 'index.db'));
+        this.db.init();
+        this.client = new TelegramClient(this.dataDir);
+        await this.client.initialize(this.config.botToken);
+        this.client.setChatId(this.config.chatId);
+        this.encryptor = new Encryptor(this.password);
+        this.compressor = new Compressor();
+    }
+    /**
+     * Stream a decrypted file from Telegram directly to the HTTP response
+     */
+    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);
+                }
+            }
+        });
+        // Pipeline: Download from Telegram -> Decrypt -> Decompress -> HTTP Response
+        await pipeline(downloadStream, decryptStream, decompressStream, res);
+    }
+    /**
+     * Handle incoming HTTP requests
+     */
+    async handleRequest(req, res) {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        // Route: GET /d/:token
+        const downloadMatch = url.pathname.match(/^\/d\/([a-f0-9]+)$/);
+        if (!downloadMatch) {
+            res.writeHead(404, { 'Content-Type': 'text/html' });
+            res.end(generateExpiredPage('invalid'));
+            return;
+        }
+        const token = downloadMatch[1];
+        const wantDownload = url.searchParams.get('download') === '1';
+        try {
+            // Clean expired shares first
+            this.db.cleanExpiredShares();
+            // Look up share
+            const share = this.db.getShare(token);
+            if (!share) {
+                res.writeHead(410, { 'Content-Type': 'text/html' });
+                res.end(generateExpiredPage('invalid'));
+                return;
+            }
+            // Check expiry
+            if (new Date(share.expires_at) < new Date()) {
+                res.writeHead(410, { 'Content-Type': 'text/html' });
+                res.end(generateExpiredPage('expired'));
+                return;
+            }
+            // Check download limit
+            if (share.download_count >= share.max_downloads) {
+                res.writeHead(410, { 'Content-Type': 'text/html' });
+                res.end(generateExpiredPage('used'));
+                return;
+            }
+            // Get file record
+            const fileRecord = this.db.db.prepare('SELECT * FROM files WHERE id = ?').get(share.file_id);
+            if (!fileRecord) {
+                res.writeHead(404, { 'Content-Type': 'text/html' });
+                res.end(generateExpiredPage('invalid'));
+                return;
+            }
+            if (!wantDownload) {
+                // Show download page
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(generateDownloadPage(share, fileRecord));
+                return;
+            }
+            // Increment download count
+            this.db.incrementShareDownload(token);
+            // Determine content type
+            const ext = path.extname(fileRecord.filename).toLowerCase();
+            const contentTypes = {
+                '.pdf': 'application/pdf',
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.txt': 'text/plain',
+                '.json': 'application/json',
+                '.zip': 'application/zip',
+                '.mp4': 'video/mp4',
+                '.mp3': 'audio/mpeg'
+            };
+            const contentType = contentTypes[ext] || 'application/octet-stream';
+            res.writeHead(200, {
+                'Content-Type': contentType,
+                'Content-Disposition': `attachment; filename="${fileRecord.filename}"`,
+                'Content-Length': fileRecord.original_size
+            });
+            // Download the file from Telegram, decrypt, decompress and stream directly to 'res'
+            await this.streamToResponse(fileRecord, res);
+        } catch (err) {
+            console.error('Share server error:', err.message);
+            res.writeHead(500, { 'Content-Type': 'text/plain' });
+            res.end('Internal server error');
+        }
+    }
+    /**
+     * Start the HTTP server
+     */
+    start() {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer((req, res) => {
+                this.handleRequest(req, res).catch(err => {
+                    console.error('Request error:', err);
+                    res.writeHead(500);
+                    res.end('Internal error');
+                });
+            });
+            this.server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${this.port} is already in use. Try --port <other-port>`));
+                } else {
+                    reject(err);
+                }
+            });
+            this.server.listen(this.port, this.host, () => {
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the HTTP server
+     */
+    stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    if (this.db) this.db.close();
+                    resolve();
+                });
+            } else {
+                if (this.db) this.db.close();
+                resolve();
+            }
+        });
+    }
+}

package/src/sync/sync.js CHANGED Viewed

@@ -29,6 +29,7 @@ export class SyncEngine extends EventEmitter {
         this.dataDir = options.dataDir;
         this.password = options.password;
         this.config = options.config;
+        this.limitRate = options.limitRate || null;
         this.watchers = new Map(); // path -> FSWatcher
         this.pendingChanges = new Map(); // path -> timeout
         this.db = null;
@@ -98,53 +99,70 @@ export class SyncEngine extends EventEmitter {
         let uploaded = 0;
         let skipped = 0;
-        for (const file of files) {
-            const existing = stateMap.get(file.relativePath);
+        // Process files with concurrency limit
+        const CONCURRENCY = 4;
+        const queue = [...files];
+        const promises = [];
-            // Check if file has changed (by mtime)
-            if (existing && existing.mtime >= file.mtime) {
-                skipped++;
-                continue;
-            }
+        const worker = async () => {
+            while (queue.length > 0) {
+                const file = queue.shift();
+                const existing = stateMap.get(file.relativePath);
-            // Calculate hash to detect actual changes
-            const hash = await hashFile(file.path);
+                // Check if file has changed (by mtime)
+                if (existing && existing.mtime >= file.mtime) {
+                    skipped++;
+                    continue;
+                }
-            if (existing && existing.file_hash === hash) {
-                // File unchanged, just update mtime
-                this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
-                skipped++;
-                continue;
-            }
+                // Calculate hash to detect actual changes
+                const hash = await hashFile(file.path);
-            // File is new or changed - upload it
-            try {
-                this.emit('file-upload-start', { file: file.relativePath });
+                if (existing && existing.file_hash === hash) {
+                    // File unchanged, just update mtime
+                    this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
+                    skipped++;
+                    continue;
+                }
-                await processFile(file.path, {
-                    password: this.password,
-                    dataDir: this.dataDir,
-                    customName: file.relativePath, // Use relative path as name
-                    config: this.config,
-                    onProgress: (msg) => this.emit('progress', { file: file.relativePath, message: msg })
-                });
+                // File is new or changed - upload it
+                try {
+                    this.emit('file-upload-start', { file: file.relativePath });
-                // Update sync state
-                this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
-                uploaded++;
+                    await processFile(file.path, {
+                        password: this.password,
+                        dataDir: this.dataDir,
+                        customName: file.relativePath, // Use relative path as name
+                        config: this.config,
+                        limitRate: this.limitRate ? Math.floor(this.limitRate / CONCURRENCY) : null,
+                        onProgress: (msg) => this.emit('progress', { file: file.relativePath, message: msg })
+                    });
-                this.emit('file-upload-complete', { file: file.relativePath });
-            } catch (err) {
-                // File might already exist, skip
-                if (err.message.includes('duplicate')) {
+                    // Update sync state
                     this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
-                    skipped++;
-                } else {
-                    this.emit('file-upload-error', { file: file.relativePath, error: err.message });
+                    uploaded++;
+                    this.emit('file-upload-complete', { file: file.relativePath });
+                } catch (err) {
+                    // File might already exist, skip
+                    if (err.message.includes('duplicate')) {
+                        this.db.updateSyncState(folder.id, file.relativePath, hash, file.mtime);
+                        skipped++;
+                    } else {
+                        // 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 });
+                    }
                 }
             }
+        };
+        for (let i = 0; i < CONCURRENCY; i++) {
+            promises.push(worker());
         }
+        await Promise.all(promises);
         this.emit('sync-complete', { folder: folderPath, uploaded, skipped });
         return { uploaded, skipped };
@@ -206,6 +224,7 @@ export class SyncEngine extends EventEmitter {
                 dataDir: this.dataDir,
                 customName: filename,
                 config: this.config,
+                limitRate: this.limitRate,
                 onProgress: (msg) => this.emit('progress', { file: filename, message: msg })
             });

package/src/telegram/client.js CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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;