@nightowne/tas-cli 1.0.0

package/src/utils/branding.js

@@ -0,0 +1,94 @@
+/**
+ * ASCII Art and Branding for TAS CLI
+ */
+
+import chalk from 'chalk';
+
+export const LOGO = `
+████████╗ █████╗ ███████╗
+╚══██╔══╝██╔══██╗██╔════╝
+   ██║   ███████║███████╗
+   ██║   ██╔══██║╚════██║
+   ██║   ██║  ██║███████║
+   ╚═╝   ╚═╝  ╚═╝╚══════╝
+`;
+
+export const TAGLINE = 'Telegram as Storage';
+export const VERSION = '1.0.0';
+
+/**
+ * Print the TAS banner
+ */
+export function printBanner() {
+    console.log(chalk.cyan(LOGO));
+    console.log(chalk.dim(`  ${TAGLINE} v${VERSION}`));
+    console.log(chalk.dim('  Free • Encrypted • Unlimited\n'));
+}
+
+/**
+ * Print a success message with icon
+ */
+export function success(msg) {
+    console.log(chalk.green('✓'), msg);
+}
+
+/**
+ * Print an error message with icon
+ */
+export function error(msg) {
+    console.log(chalk.red('✗'), msg);
+}
+
+/**
+ * Print an info message with icon
+ */
+export function info(msg) {
+    console.log(chalk.blue('ℹ'), msg);
+}
+
+/**
+ * Print a warning message with icon
+ */
+export function warn(msg) {
+    console.log(chalk.yellow('⚠'), msg);
+}
+
+/**
+ * Format file size
+ */
+export function formatSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Print a table-like display for files
+ */
+export function printFileTable(files, showTags = false) {
+    if (files.length === 0) {
+        console.log(chalk.yellow('\n📭 No files stored yet.\n'));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n📦 Stored Files (${files.length})\n`));
+    console.log(chalk.dim('─'.repeat(60)));
+
+    for (const file of files) {
+        const size = formatSize(file.original_size).padEnd(10);
+        const name = chalk.white(file.filename);
+        const date = new Date(file.created_at).toLocaleDateString();
+
+        console.log(`  ${chalk.blue('●')} ${name}`);
+        console.log(chalk.dim(`    ${size} • ${date} • ${file.chunks} chunk(s)`));
+
+        if (showTags && file.tags && file.tags.length > 0) {
+            console.log(chalk.magenta(`    🏷️  ${file.tags.join(', ')}`));
+        }
+    }
+
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log();
+}

package/src/utils/chunker.js

@@ -0,0 +1,155 @@
+/**
+ * File chunking utilities for large files
+ * WhatsApp document limit is ~2GB, we use 1.9GB chunks to be safe
+ */
+
+const MAX_CHUNK_SIZE = 1.9 * 1024 * 1024 * 1024; // 1.9 GB
+
+export class Chunker {
+    /**
+     * Split data into chunks if needed
+     * Returns array of { index, total, data }
+     */
+    chunk(data) {
+        const totalSize = data.length;
+
+        // If small enough, return as single chunk
+        if (totalSize <= MAX_CHUNK_SIZE) {
+            return [{
+                index: 0,
+                total: 1,
+                data: data
+            }];
+        }
+
+        // Split into chunks
+        const chunks = [];
+        const numChunks = Math.ceil(totalSize / MAX_CHUNK_SIZE);
+
+        for (let i = 0; i < numChunks; i++) {
+            const start = i * MAX_CHUNK_SIZE;
+            const end = Math.min(start + MAX_CHUNK_SIZE, totalSize);
+
+            chunks.push({
+                index: i,
+                total: numChunks,
+                data: data.subarray(start, end)
+            });
+        }
+
+        return chunks;
+    }
+
+    /**
+     * Reassemble chunks into original data
+     * Chunks must be in order
+     */
+    reassemble(chunks) {
+        // Sort by index just in case
+        chunks.sort((a, b) => a.index - b.index);
+
+        // Verify we have all chunks
+        const total = chunks[0].total;
+        if (chunks.length !== total) {
+            throw new Error(`Missing chunks: have ${chunks.length}, need ${total}`);
+        }
+
+        // Concatenate
+        return Buffer.concat(chunks.map(c => c.data));
+    }
+}
+
+/**
+ * Create WAS file header
+ */
+export function createHeader(filename, originalSize, chunkIndex, totalChunks, flags) {
+    const header = Buffer.alloc(64);
+    let offset = 0;
+
+    // Magic bytes "WAS1"
+    header.write('WAS1', offset);
+    offset += 4;
+
+    // Version (1)
+    header.writeUInt16LE(1, offset);
+    offset += 2;
+
+    // Flags (bit 0: compressed)
+    header.writeUInt16LE(flags, offset);
+    offset += 2;
+
+    // Original size (8 bytes for large files)
+    header.writeBigUInt64LE(BigInt(originalSize), offset);
+    offset += 8;
+
+    // Chunk index
+    header.writeUInt16LE(chunkIndex, offset);
+    offset += 2;
+
+    // Total chunks
+    header.writeUInt16LE(totalChunks, offset);
+    offset += 2;
+
+    // Filename length
+    const filenameBytes = Buffer.from(filename, 'utf-8').subarray(0, 42);
+    header.writeUInt16LE(filenameBytes.length, offset);
+    offset += 2;
+
+    // Filename (max 42 bytes)
+    filenameBytes.copy(header, offset);
+
+    return header;
+}
+
+/**
+ * Parse WAS file header
+ */
+export function parseHeader(buffer) {
+    let offset = 0;
+
+    // Check magic bytes
+    const magic = buffer.subarray(0, 4).toString();
+    if (magic !== 'WAS1') {
+        throw new Error('Invalid WAS file: bad magic bytes');
+    }
+    offset += 4;
+
+    // Version
+    const version = buffer.readUInt16LE(offset);
+    offset += 2;
+
+    // Flags
+    const flags = buffer.readUInt16LE(offset);
+    offset += 2;
+
+    // Original size
+    const originalSize = Number(buffer.readBigUInt64LE(offset));
+    offset += 8;
+
+    // Chunk index
+    const chunkIndex = buffer.readUInt16LE(offset);
+    offset += 2;
+
+    // Total chunks
+    const totalChunks = buffer.readUInt16LE(offset);
+    offset += 2;
+
+    // Filename length
+    const filenameLength = buffer.readUInt16LE(offset);
+    offset += 2;
+
+    // Filename
+    const filename = buffer.subarray(offset, offset + filenameLength).toString('utf-8');
+
+    return {
+        version,
+        flags,
+        compressed: (flags & 1) === 1,
+        originalSize,
+        chunkIndex,
+        totalChunks,
+        filename
+    };
+}
+
+export const HEADER_SIZE = 64;

package/src/utils/compression.js

@@ -0,0 +1,84 @@
+/**
+ * Compression utilities - gzip with smart bypass for already-compressed formats
+ */
+
+import zlib from 'zlib';
+import { promisify } from 'util';
+import path from 'path';
+
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+
+// File extensions that are already compressed (skip compression for these)
+const SKIP_COMPRESSION = new Set([
+    // Images
+    '.jpg', '.jpeg', '.png', '.gif', '.webp', '.avif', '.heic', '.heif',
+    // Video
+    '.mp4', '.mkv', '.avi', '.mov', '.webm', '.m4v',
+    // Audio
+    '.mp3', '.aac', '.m4a', '.ogg', '.opus', '.flac', '.wma',
+    // Archives
+    '.zip', '.rar', '.7z', '.gz', '.bz2', '.xz', '.tar.gz', '.tgz',
+    // Documents (already compressed internally)
+    '.pdf', '.docx', '.xlsx', '.pptx', '.epub',
+    // Other
+    '.dmg', '.iso', '.apk', '.ipa'
+]);
+
+export class Compressor {
+    /**
+     * Check if a file should skip compression
+     */
+    shouldSkip(filename) {
+        const ext = path.extname(filename).toLowerCase();
+        return SKIP_COMPRESSION.has(ext);
+    }
+
+    /**
+     * Compress data using gzip
+     * Returns: { data: Buffer, compressed: boolean }
+     */
+    async compress(data, filename = '') {
+        // Skip if already compressed format
+        if (this.shouldSkip(filename)) {
+            return {
+                data: data,
+                compressed: false
+            };
+        }
+
+        try {
+            const compressed = await gzip(data, { level: 6 });
+
+            // Only use compression if it actually reduces size
+            if (compressed.length < data.length) {
+                return {
+                    data: compressed,
+                    compressed: true
+                };
+            }
+
+            return {
+                data: data,
+                compressed: false
+            };
+        } catch (err) {
+            // If compression fails, return original
+            return {
+                data: data,
+                compressed: false
+            };
+        }
+    }
+
+    /**
+     * Decompress gzip data
+     */
+    async decompress(data, wasCompressed) {
+        if (!wasCompressed) {
+            return data;
+        }
+
+        return await gunzip(data);
+    }
+}

package/systemd/README.md

@@ -0,0 +1,32 @@
+# TAS Systemd Service Setup
+
+## Install the sync service to start automatically on boot:
+
+```bash
+# 1. Copy service file
+sudo cp systemd/tas-sync.service /etc/systemd/user/
+
+# 2. Edit the service file - replace USER with your username
+sudo nano /etc/systemd/user/tas-sync.service
+
+# 3. Create password file (for headless operation)
+echo "your-password" > ~/.tas-password
+chmod 600 ~/.tas-password
+
+# 4. Enable and start the service
+systemctl --user daemon-reload
+systemctl --user enable tas-sync
+systemctl --user start tas-sync
+
+# 5. Check status
+systemctl --user status tas-sync
+
+# 6. View logs
+journalctl --user -u tas-sync -f
+```
+
+## To stop the service:
+```bash
+systemctl --user stop tas-sync
+systemctl --user disable tas-sync
+```

package/systemd/tas-sync.service

@@ -0,0 +1,21 @@
+[Unit]
+Description=TAS - Telegram as Storage Sync Service
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/node /home/USER/tas/src/cli.js sync start --password-file /home/USER/.tas-password
+Restart=on-failure
+RestartSec=10
+StandardOutput=journal
+StandardError=journal
+
+# Security hardening
+NoNewPrivileges=true
+ProtectSystem=strict
+ProtectHome=read-only
+ReadWritePaths=/home/USER/tas/data /home/USER/TelegramCloud
+
+[Install]
+WantedBy=default.target