@nightowne/tas-cli 1.1.1 → 2.1.0

package/src/utils/cli-helpers.js

@@ -0,0 +1,145 @@
+/**
+ * CLI Helper utilities
+ * Shared logic for commands
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { Encryptor } from '../crypto/encryption.js';
+
+/**
+ * Get password from command-line option, environment variable, or interactive prompt
+ * @param {string} passwordOption - Password from --password flag (if provided)
+ * @param {boolean} allowCache - Allow caching via TAS_PASSWORD env var
+ * @returns {Promise<string>}
+ */
+export async function getPassword(passwordOption, allowCache = true) {
+    // Priority: CLI flag > Environment variable > Interactive prompt
+    
+    if (passwordOption) {
+        return passwordOption;
+    }
+
+    if (allowCache && process.env.TAS_PASSWORD) {
+        return process.env.TAS_PASSWORD;
+    }
+
+    const { password } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Enter your encryption password:',
+            mask: '*'
+        }
+    ]);
+
+    return password;
+}
+
+/**
+ * Verify password against config
+ * @param {string} password - Password to verify
+ * @param {Object} config - Config object with passwordHash
+ * @returns {boolean}
+ */
+export function verifyPassword(password, config) {
+    const encryptor = new Encryptor(password);
+    return encryptor.getPasswordHash() === config.passwordHash;
+}
+
+/**
+ * Validate config structure and content
+ * @param {Object} config - Config to validate
+ * @returns {Object} - { valid: boolean, errors: string[] }
+ */
+export function validateConfig(config) {
+    const errors = [];
+
+    if (!config) {
+        errors.push('Config is null or undefined');
+        return { valid: false, errors };
+    }
+
+    if (!config.botToken || typeof config.botToken !== 'string') {
+        errors.push('Missing or invalid botToken');
+    }
+
+    if (!config.botToken?.includes(':')) {
+        errors.push('Invalid bot token format (should contain :)');
+    }
+
+    if (!config.chatId || (typeof config.chatId !== 'number' && typeof config.chatId !== 'string')) {
+        errors.push('Missing or invalid chatId');
+    }
+
+    if (!config.passwordHash || typeof config.passwordHash !== 'string') {
+        errors.push('Missing or invalid passwordHash');
+    }
+
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+
+/**
+ * Load and validate config
+ * @param {string} dataDir - Data directory path
+ * @returns {Object|null} - Config object or null if not found
+ */
+export function loadConfig(dataDir) {
+    const configPath = path.join(dataDir, 'config.json');
+    
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        const validation = validateConfig(config);
+
+        if (!validation.valid) {
+            throw new Error(`Invalid config: ${validation.errors.join(', ')}`);
+        }
+
+        return config;
+    } catch (err) {
+        throw new Error(`Config error: ${err.message}`);
+    }
+}
+
+/**
+ * Ensure TAS is initialized
+ * @param {string} dataDir - Data directory path
+ * @returns {Object} - Config object
+ */
+export function requireConfig(dataDir) {
+    const config = loadConfig(dataDir);
+    
+    if (!config) {
+        console.log(chalk.red('✗ TAS not initialized. Run `tas init` first.'));
+        process.exit(1);
+    }
+
+    return config;
+}
+
+/**
+ * Get and verify password with proper error handling
+ * @param {string} passwordOption - Password from CLI flag
+ * @param {string} dataDir - Data directory path
+ * @returns {Promise<string>} - Verified password
+ */
+export async function getAndVerifyPassword(passwordOption, dataDir) {
+    const config = requireConfig(dataDir);
+    const password = await getPassword(passwordOption);
+
+    if (!verifyPassword(password, config)) {
+        console.log(chalk.red('✗ Incorrect password'));
+        process.exit(1);
+    }
+
+    return password;
+}

package/src/utils/compression.js

@@ -8,6 +8,7 @@ import path from 'path';
 
 const gzip = promisify(zlib.gzip);
 const gunzip = promisify(zlib.gunzip);
+import { PassThrough } from 'stream';
 
 // File extensions that are already compressed (skip compression for these)
 const SKIP_COMPRESSION = new Set([
@@ -71,6 +72,24 @@ export class Compressor {
         }
     }
 
+    /**
+     * Get a compression transform stream
+     * Returns: { stream: Transform, compressed: boolean }
+     */
+    getCompressStream(filename = '') {
+        if (this.shouldSkip(filename)) {
+            return {
+                stream: new PassThrough(),
+                compressed: false
+            };
+        }
+
+        return {
+            stream: zlib.createGzip({ level: 6 }),
+            compressed: true
+        };
+    }
+
     /**
      * Decompress gzip data
      */
@@ -81,4 +100,15 @@ export class Compressor {
 
         return await gunzip(data);
     }
+
+    /**
+     * Get a decompression transform stream
+     */
+    getDecompressStream(wasCompressed) {
+        if (!wasCompressed) {
+            return new PassThrough();
+        }
+
+        return zlib.createGunzip();
+    }
 }

package/src/utils/throttle.js

@@ -0,0 +1,26 @@
+import { Transform } from 'stream';
+
+export class Throttle extends Transform {
+    constructor(bytesPerSecond) {
+        super();
+        this.bytesPerSecond = bytesPerSecond;
+        this.passed = 0;
+        this.startTime = Date.now();
+    }
+
+    _transform(chunk, encoding, callback) {
+        this.passed += chunk.length;
+        const elapsed = Date.now() - this.startTime;
+        const expectedTime = (this.passed / this.bytesPerSecond) * 1000;
+
+        if (expectedTime > elapsed) {
+            setTimeout(() => {
+                this.push(chunk);
+                callback();
+            }, expectedTime - elapsed);
+        } else {
+            this.push(chunk);
+            callback();
+        }
+    }
+}