@fazetitans/fscopy 1.1.3 → 1.2.1

package/src/utils/output.ts

@@ -0,0 +1,265 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { Stats, LogEntry } from '../types.js';
+
+/**
+ * Parse a size string like "10MB" or "1GB" into bytes.
+ * Supports: B, KB, MB, GB (case insensitive)
+ * Returns 0 for invalid or "0" input.
+ */
+export function parseSize(sizeStr: string | undefined): number {
+    if (!sizeStr || sizeStr === '0') return 0;
+
+    const sizeRegex = /^(\d+(?:\.\d+)?)\s*(B|KB|MB|GB)?$/i;
+    const match = sizeRegex.exec(sizeStr.trim());
+    if (!match) return 0;
+
+    const value = Number.parseFloat(match[1]);
+    const unit = (match[2] || 'B').toUpperCase();
+
+    const multipliers: Record<string, number> = {
+        B: 1,
+        KB: 1024,
+        MB: 1024 * 1024,
+        GB: 1024 * 1024 * 1024,
+    };
+
+    return Math.floor(value * (multipliers[unit] || 1));
+}
+
+export interface OutputOptions {
+    quiet: boolean;
+    json: boolean;
+    logFile?: string;
+    maxLogSize?: number; // Max log file size in bytes (0 = unlimited)
+    maxLogFiles?: number; // Max number of rotated log files to keep
+}
+
+/**
+ * Unified output manager for console and file logging.
+ * Handles quiet mode (--quiet) and JSON mode (--json).
+ */
+export class Output {
+    private readonly options: OutputOptions;
+    private readonly entries: LogEntry[] = [];
+    private readonly startTime: Date;
+
+    constructor(options: Partial<OutputOptions> = {}) {
+        this.options = {
+            quiet: options.quiet ?? false,
+            json: options.json ?? false,
+            logFile: options.logFile,
+            maxLogSize: options.maxLogSize ?? 0,
+            maxLogFiles: options.maxLogFiles ?? 5,
+        };
+        this.startTime = new Date();
+    }
+
+    // ==========================================================================
+    // Initialization
+    // ==========================================================================
+
+    init(): void {
+        if (this.options.logFile) {
+            this.rotateLogIfNeeded();
+            const header = `# fscopy transfer log\n# Started: ${this.startTime.toISOString()}\n\n`;
+            fs.writeFileSync(this.options.logFile, header);
+        }
+    }
+
+    /**
+     * Rotate log file if it exceeds maxLogSize.
+     * Creates numbered backups: log.1.ext, log.2.ext, etc.
+     */
+    private rotateLogIfNeeded(): void {
+        const logFile = this.options.logFile;
+        const maxSize = this.options.maxLogSize ?? 0;
+        const maxFiles = this.options.maxLogFiles ?? 5;
+
+        if (!logFile || maxSize <= 0) return;
+        if (!fs.existsSync(logFile)) return;
+
+        const stats = fs.statSync(logFile);
+        if (stats.size < maxSize) return;
+
+        const dir = path.dirname(logFile);
+        const ext = path.extname(logFile);
+        const base = path.basename(logFile, ext);
+
+        // Delete oldest backup if at max
+        const oldestPath = path.join(dir, `${base}.${maxFiles}${ext}`);
+        if (fs.existsSync(oldestPath)) {
+            fs.unlinkSync(oldestPath);
+        }
+
+        // Shift existing backups: .4 -> .5, .3 -> .4, etc.
+        for (let i = maxFiles - 1; i >= 1; i--) {
+            const from = path.join(dir, `${base}.${i}${ext}`);
+            const to = path.join(dir, `${base}.${i + 1}${ext}`);
+            if (fs.existsSync(from)) {
+                fs.renameSync(from, to);
+            }
+        }
+
+        // Rename current to .1
+        const backupPath = path.join(dir, `${base}.1${ext}`);
+        fs.renameSync(logFile, backupPath);
+    }
+
+    // ==========================================================================
+    // Console Output (respects quiet mode, skipped in JSON mode)
+    // ==========================================================================
+
+    /** Print info message to console */
+    print(message: string): void {
+        if (!this.options.json) {
+            console.log(message);
+        }
+    }
+
+    /** Print message (skipped in quiet mode) */
+    private printIfNotQuiet(message: string): void {
+        if (!this.options.quiet && !this.options.json) {
+            console.log(message);
+        }
+    }
+
+    /** Print info message (skipped in quiet mode) */
+    info(message: string): void {
+        this.printIfNotQuiet(message);
+    }
+
+    /** Print success message (skipped in quiet mode) */
+    success(message: string): void {
+        this.printIfNotQuiet(message);
+    }
+
+    /** Print warning message (always shown, except in JSON mode) */
+    warn(message: string): void {
+        if (!this.options.json) {
+            console.warn(message);
+        }
+    }
+
+    /** Print error message (always shown, except in JSON mode) */
+    error(message: string): void {
+        if (!this.options.json) {
+            console.error(message);
+        }
+    }
+
+    /** Print a blank line */
+    blank(): void {
+        if (!this.options.quiet && !this.options.json) {
+            console.log('');
+        }
+    }
+
+    /** Print a separator line */
+    separator(char: string = '=', length: number = 60): void {
+        if (!this.options.quiet && !this.options.json) {
+            console.log(char.repeat(length));
+        }
+    }
+
+    /** Print a header with separators */
+    header(title: string): void {
+        if (!this.options.quiet && !this.options.json) {
+            console.log('='.repeat(60));
+            console.log(title);
+            console.log('='.repeat(60));
+        }
+    }
+
+    // ==========================================================================
+    // File Logging (always writes if logFile is set)
+    // ==========================================================================
+
+    /** Log entry to file only */
+    log(level: string, message: string, data: Record<string, unknown> = {}): void {
+        const entry: LogEntry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message,
+            ...data,
+        };
+        this.entries.push(entry);
+
+        if (this.options.logFile) {
+            const line =
+                `[${entry.timestamp}] [${level}] ${message}` +
+                (Object.keys(data).length > 0 ? ` ${JSON.stringify(data)}` : '') +
+                '\n';
+            fs.appendFileSync(this.options.logFile, line);
+        }
+    }
+
+    /** Log info to file */
+    logInfo(message: string, data?: Record<string, unknown>): void {
+        this.log('INFO', message, data);
+    }
+
+    /** Log error to file */
+    logError(message: string, data?: Record<string, unknown>): void {
+        this.log('ERROR', message, data);
+    }
+
+    /** Log success to file */
+    logSuccess(message: string, data?: Record<string, unknown>): void {
+        this.log('SUCCESS', message, data);
+    }
+
+    /** Write summary to log file */
+    logSummary(stats: Stats, duration: string): void {
+        if (this.options.logFile) {
+            let summary = `\n# Summary\n# Collections: ${stats.collectionsProcessed}\n`;
+            if (stats.documentsDeleted > 0) {
+                summary += `# Deleted: ${stats.documentsDeleted}\n`;
+            }
+            summary += `# Transferred: ${stats.documentsTransferred}\n`;
+            if (stats.conflicts > 0) {
+                summary += `# Conflicts: ${stats.conflicts}\n`;
+            }
+            summary += `# Errors: ${stats.errors}\n# Duration: ${duration}s\n`;
+            fs.appendFileSync(this.options.logFile, summary);
+        }
+    }
+
+    // ==========================================================================
+    // JSON Output
+    // ==========================================================================
+
+    /** Print JSON output (only in JSON mode) */
+    json(data: unknown): void {
+        if (this.options.json) {
+            console.log(JSON.stringify(data, null, 2));
+        }
+    }
+
+    // ==========================================================================
+    // Helpers
+    // ==========================================================================
+
+    get isQuiet(): boolean {
+        return this.options.quiet;
+    }
+
+    get isJson(): boolean {
+        return this.options.json;
+    }
+
+    get logFile(): string | undefined {
+        return this.options.logFile;
+    }
+}
+
+// Default singleton instance (can be replaced)
+let defaultOutput: Output = new Output();
+
+export function setDefaultOutput(output: Output): void {
+    defaultOutput = output;
+}
+
+export function getDefaultOutput(): Output {
+    return defaultOutput;
+}

package/src/utils/progress.ts

@@ -0,0 +1,102 @@
+import cliProgress from 'cli-progress';
+import type { Stats } from '../types.js';
+
+export interface ProgressBarOptions {
+    format?: string;
+    barCompleteChar?: string;
+    barIncompleteChar?: string;
+    hideCursor?: boolean;
+}
+
+const DEFAULT_OPTIONS: ProgressBarOptions = {
+    format: '📦 Progress |{bar}| {percentage}% | {value}/{total} docs | {speed} docs/s | ETA: {eta}s',
+    barCompleteChar: '█',
+    barIncompleteChar: '░',
+    hideCursor: true,
+};
+
+/**
+ * Wrapper around cli-progress that handles speed calculation and cleanup.
+ * Eliminates the need for type hacks to store the speed interval.
+ */
+export class ProgressBarWrapper {
+    private bar: cliProgress.SingleBar | null = null;
+    private speedInterval: NodeJS.Timeout | null = null;
+    private lastDocsTransferred = 0;
+    private lastTime = Date.now();
+
+    constructor(private readonly options: ProgressBarOptions = {}) {}
+
+    /**
+     * Start the progress bar with the given total and stats reference.
+     * The stats object is used to read documentsTransferred for speed calculation.
+     */
+    start(total: number, stats: Stats): void {
+        if (total <= 0) return;
+
+        const mergedOptions = { ...DEFAULT_OPTIONS, ...this.options };
+        this.bar = new cliProgress.SingleBar({
+            format: mergedOptions.format,
+            barCompleteChar: mergedOptions.barCompleteChar,
+            barIncompleteChar: mergedOptions.barIncompleteChar,
+            hideCursor: mergedOptions.hideCursor,
+        });
+
+        this.bar.start(total, 0, { speed: '0' });
+        this.lastDocsTransferred = 0;
+        this.lastTime = Date.now();
+
+        this.speedInterval = setInterval(() => {
+            this.updateSpeed(stats);
+        }, 500);
+    }
+
+    /**
+     * Increment the progress bar by 1.
+     */
+    increment(): void {
+        if (this.bar) {
+            this.bar.increment();
+        }
+    }
+
+    /**
+     * Update the speed display based on current stats.
+     */
+    private updateSpeed(stats: Stats): void {
+        if (!this.bar) return;
+
+        const now = Date.now();
+        const timeDiff = (now - this.lastTime) / 1000;
+        const currentDocs = stats.documentsTransferred;
+
+        if (timeDiff > 0) {
+            const docsDiff = currentDocs - this.lastDocsTransferred;
+            const speed = Math.round(docsDiff / timeDiff);
+            this.lastDocsTransferred = currentDocs;
+            this.lastTime = now;
+            this.bar.update({ speed: String(speed) });
+        }
+    }
+
+    /**
+     * Stop the progress bar and clean up the speed interval.
+     */
+    stop(): void {
+        if (this.speedInterval) {
+            clearInterval(this.speedInterval);
+            this.speedInterval = null;
+        }
+        if (this.bar) {
+            this.bar.stop();
+            this.bar = null;
+        }
+    }
+
+    /**
+     * Check if the progress bar is active.
+     */
+    get isActive(): boolean {
+        return this.bar !== null;
+    }
+}

package/src/utils/rate-limiter.ts

@@ -51,8 +51,10 @@ export class RateLimiter {
 
         await this.sleep(waitTime);
 
-        // After waiting, we should have enough tokens
-        this.tokens = 0; // We consumed them all
+        // After waiting, calculate remaining tokens:
+        // tokens accumulated = waitTime * refillRate (may exceed tokensNeeded due to ceiling)
+        const tokensAccumulated = waitTime * this.refillRate;
+        this.tokens = Math.min(this.maxTokens, this.tokens + tokensAccumulated - count);
         this.lastRefill = Date.now();
     }
 

package/src/webhook/index.ts

@@ -1,5 +1,5 @@
 import type { Stats } from '../types.js';
-import type { Logger } from '../utils/logger.js';
+import type { Output } from '../utils/output.js';
 
 export interface WebhookPayload {
     source: string;
@@ -108,7 +108,7 @@ export function formatDiscordPayload(payload: WebhookPayload): Record<string, un
 export async function sendWebhook(
     webhookUrl: string,
     payload: WebhookPayload,
-    logger: Logger
+    output: Output
 ): Promise<void> {
     const webhookType = detectWebhookType(webhookUrl);
 
@@ -136,11 +136,11 @@ export async function sendWebhook(
             throw new Error(`HTTP ${response.status}: ${errorText}`);
         }
 
-        logger.info(`Webhook sent successfully (${webhookType})`, { url: webhookUrl });
-        console.log(`📤 Webhook notification sent (${webhookType})`);
+        output.logInfo(`Webhook sent successfully (${webhookType})`, { url: webhookUrl });
+        output.info(`📤 Webhook notification sent (${webhookType})`);
     } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Failed to send webhook: ${message}`, { url: webhookUrl });
-        console.error(`⚠️  Failed to send webhook: ${message}`);
+        output.logError(`Failed to send webhook: ${message}`, { url: webhookUrl });
+        output.warn(`⚠️  Failed to send webhook: ${message}`);
     }
 }