thinkncollab-shell 0.0.20 → 2.0.0-beta.1

package/src/events/notifications.js

@@ -1,184 +0,0 @@
-/*
-  Notification System for ThinkNCollab Shell
- */
-
-const EventEmitter = require('events');
-const chalk = require('chalk');
-
-class NotificationManager extends EventEmitter {
-    constructor(options = {}) {
-        super();
-        
-        this.options = {
-            sound: options.sound || false,
-            desktop: options.desktop || false,
-            ...options
-        };
-        
-        this.notifications = [];
-        this.maxNotifications = 100;
-        this.unreadCount = 0;
-    }
-    
-    /* Show a notification
-     */
-    show(notification) {
-        const notif = {
-            id: `notif_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-            type: notification.type || 'info',
-            title: notification.title || 'Notification',
-            message: notification.message,
-            timestamp: new Date(),
-            read: false,
-            data: notification.data || {}
-        };
-        
-        this.notifications.unshift(notif);
-        this.unreadCount++;
-        
-        // Trim old notifications
-        if (this.notifications.length > this.maxNotifications) {
-            this.notifications.pop();
-        }
-        
-        // Emit event
-        this.emit('notification', notif);
-        
-        // Show in console
-        this.showInConsole(notif);
-        
-        // Desktop notification
-        if (this.options.desktop) {
-            this.showDesktopNotification(notif);
-        }
-        
-        // Sound
-        if (this.options.sound) {
-            this.playSound();
-        }
-        
-        return notif;
-    }
-    
-    /* Show notification in console
-     */
-    showInConsole(notification) {
-        let color = chalk.blue;
-        let symbol = 'ℹ';
-        
-        switch (notification.type) {
-            case 'success':
-                color = chalk.green;
-                symbol = '✓';
-                break;
-            case 'warning':
-                color = chalk.yellow;
-                symbol = '⚠';
-                break;
-            case 'error':
-                color = chalk.red;
-                symbol = '✗';
-                break;
-            case 'info':
-            default:
-                color = chalk.blue;
-                symbol = 'ℹ';
-                break;
-        }
-        
-        console.log(color(`${symbol} ${notification.title}: ${notification.message}`));
-    }
-    
-    /* Show desktop notification (if supported)
-     */
-    showDesktopNotification(notification) {
-        // Check if running in Electron
-        if (process.type === 'renderer' || process.type === 'browser') {
-            try {
-                const { Notification } = require('electron');
-                new Notification({
-                    title: notification.title,
-                    body: notification.message,
-                    silent: !this.options.sound
-                }).show();
-            } catch (error) {
-                // Electron not available
-            }
-        }
-    }
-    
-    /* Play notification sound
-     */
-   playSound() {
-    process.stdout.write('\x07'); // terminal bell — zero dependencies
-}
-    
-    /* Mark notification as read
-     */
-    markAsRead(id) {
-        const notif = this.notifications.find(n => n.id === id);
-        if (notif && !notif.read) {
-            notif.read = true;
-            this.unreadCount--;
-            this.emit('read', notif);
-        }
-    }
-    
-    /* Mark all as read
-     */
-    markAllAsRead() {
-        this.notifications.forEach(n => {
-            if (!n.read) {
-                n.read = true;
-            }
-        });
-        this.unreadCount = 0;
-        this.emit('allRead');
-    }
-    
-    /* Get unread notifications
-     */
-    getUnread() {
-        return this.notifications.filter(n => !n.read);
-    }
-    
-    /* Get all notifications
-     */
-    getAll() {
-        return this.notifications;
-    }
-    
-    /* Clear all notifications
-     */
-    clear() {
-        this.notifications = [];
-        this.unreadCount = 0;
-        this.emit('cleared');
-    }
-    
-    /* Create success notification
-     */
-    success(title, message, data = {}) {
-        return this.show({ type: 'success', title, message, data });
-    }
-    
-    /* Create error notification
-     */
-    error(title, message, data = {}) {
-        return this.show({ type: 'error', title, message, data });
-    }
-    
-    /* Create warning notification
-     */
-    warning(title, message, data = {}) {
-        return this.show({ type: 'warning', title, message, data });
-    }
-    
-    /* Create info notification
-     */
-    info(title, message, data = {}) {
-        return this.show({ type: 'info', title, message, data });
-    }
-}
-
-module.exports = NotificationManager;

package/src/utils/logger.js

@@ -1,159 +0,0 @@
-/* Logger for ThinkNCollab Shell
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
-
-class Logger {
-    constructor(options = {}) {
-        this.options = {
-            logDir: options.logDir || path.join(os.homedir(), '.thinkncollab', 'logs'),
-            level: options.level || 'info',
-            maxFiles: options.maxFiles || 5,
-            maxSize: options.maxSize || 10 * 1024 * 1024, // 10MB
-            ...options
-        };
-        
-        // Ensure log directory exists
-        fs.ensureDirSync(this.options.logDir);
-        
-        this.levels = {
-            debug: 0,
-            info: 1,
-            warn: 2,
-            error: 3
-        };
-        
-        this.currentLogFile = this.getLogFileName();
-    }
-    
-    /* Get log file name
-     */
-    getLogFileName() {
-        const date = new Date().toISOString().split('T')[0];
-        return path.join(this.options.logDir, `thinknsh-${date}.log`);
-    }
-    
-    /* Write to log file
-     */
-    async write(level, message, data = null) {
-        if (this.levels[level] < this.levels[this.options.level]) {
-            return;
-        }
-        
-        const logEntry = {
-            timestamp: new Date().toISOString(),
-            level,
-            message,
-            data,
-            pid: process.pid
-        };
-        
-        const logLine = JSON.stringify(logEntry) + '\n';
-        
-        try {
-            await fs.appendFile(this.currentLogFile, logLine);
-            await this.rotateIfNeeded();
-        } catch (error) {
-            console.error('Failed to write log:', error);
-        }
-    }
-    
-    /* Rotate log files if needed
-     */
-    async rotateIfNeeded() {
-        try {
-            const stat = await fs.stat(this.currentLogFile);
-            
-            if (stat.size > this.options.maxSize) {
-                // Rename current file
-                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-                const rotatedFile = this.currentLogFile.replace('.log', `-${timestamp}.log`);
-                await fs.rename(this.currentLogFile, rotatedFile);
-                
-                // Create new log file
-                this.currentLogFile = this.getLogFileName();
-                
-                // Clean up old files
-                await this.cleanOldLogs();
-            }
-        } catch (error) {
-            // File might not exist yet
-        }
-    }
-    
-    /* Clean old log files
-     */
-    async cleanOldLogs() {
-        try {
-            const files = await fs.readdir(this.options.logDir);
-            const logFiles = files
-                .filter(f => f.startsWith('thinknsh-') && f.endsWith('.log'))
-                .map(f => ({
-                    name: f,
-                    path: path.join(this.options.logDir, f),
-                    time: fs.statSync(path.join(this.options.logDir, f)).mtime.getTime()
-                }))
-                .sort((a, b) => b.time - a.time);
-            
-            // Keep only maxFiles most recent
-            if (logFiles.length > this.options.maxFiles) {
-                const toDelete = logFiles.slice(this.options.maxFiles);
-                for (const file of toDelete) {
-                    await fs.remove(file.path);
-                }
-            }
-        } catch (error) {
-            console.error('Failed to clean old logs:', error);
-        }
-    }
-    
-    /* Debug log
-     */
-    debug(message, data = null) {
-        return this.write('debug', message, data);
-    }
-    
-    /* Info log
-     */
-    info(message, data = null) {
-        return this.write('info', message, data);
-    }
-    
-    /* Warn log
-     */
-    warn(message, data = null) {
-        return this.write('warn', message, data);
-    }
-    
-    /* Error log
-     */
-    error(message, data = null) {
-        return this.write('error', message, data);
-    }
-    
-    /* Get recent logs
-     */
-    async getRecentLogs(lines = 100) {
-        try {
-            if (!await fs.pathExists(this.currentLogFile)) {
-                return [];
-            }
-            
-            const content = await fs.readFile(this.currentLogFile, 'utf8');
-            const logs = content
-                .split('\n')
-                .filter(line => line.trim())
-                .map(line => JSON.parse(line))
-                .slice(-lines);
-            
-            return logs;
-        } catch (error) {
-            console.error('Failed to read logs:', error);
-            return [];
-        }
-    }
-}
-
-module.exports = Logger;

package/src/utils/terminalCrypto.js

@@ -1,47 +0,0 @@
-/**
- * src/utils/terminalCrypto.js
- * CLI-side AES-256-GCM End-to-End Encryption (E2EE) module
- */
-
-const crypto = require('crypto');
-
-function deriveKey(secret, salt = 'thinkncollab-e2ee-salt') {
-  return new Promise((resolve, reject) => {
-    crypto.pbkdf2(secret, salt, 100000, 32, 'sha256', (err, derivedKey) => {
-      if (err) return reject(err);
-      resolve(derivedKey);
-    });
-  });
-}
-
-function encryptPayload(plaintext, key) {
-  const iv = crypto.randomBytes(12);
-  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-  
-  let encrypted = cipher.update(plaintext, 'utf8', 'hex');
-  encrypted += cipher.final('hex');
-  const authTag = cipher.getAuthTag().toString('hex');
-
-  return {
-    ciphertext: encrypted,
-    iv: iv.toString('hex'),
-    authTag: authTag
-  };
-}
-
-function decryptPayload(ciphertext, ivHex, authTagHex, key) {
-  const iv = Buffer.from(ivHex, 'hex');
-  const authTag = Buffer.from(authTagHex, 'hex');
-  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
-  decipher.setAuthTag(authTag);
-
-  let decrypted = decipher.update(ciphertext, 'hex', 'utf8');
-  decrypted += decipher.final('utf8');
-  return decrypted;
-}
-
-module.exports = {
-  deriveKey,
-  encryptPayload,
-  decryptPayload
-};