tabby-ai-assistant 1.0.0

package/src/utils/encryption.utils.ts

@@ -0,0 +1,271 @@
+import * as CryptoJS from 'crypto-js';
+
+/**
+ * 加密工具类
+ * 提供安全的加密和解密功能
+ */
+
+const KEY_SIZE = 256;
+const IV_SIZE = 16;
+
+/**
+ * 生成随机密钥
+ */
+export function generateKey(): string {
+    return CryptoJS.lib.WordArray.random(KEY_SIZE / 8).toString();
+}
+
+/**
+ * 生成随机初始化向量
+ */
+export function generateIV(): string {
+    return CryptoJS.lib.WordArray.random(IV_SIZE).toString();
+}
+
+/**
+ * 使用AES加密字符串
+ */
+export function encrypt(text: string, key: string): string {
+    if (!text || !key) {
+        throw new Error('文本和密钥不能为空');
+    }
+
+    try {
+        const encrypted = CryptoJS.AES.encrypt(text, key);
+        return encrypted.toString();
+    } catch (error) {
+        throw new Error(`加密失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 使用AES解密字符串
+ */
+export function decrypt(encryptedText: string, key: string): string {
+    if (!encryptedText || !key) {
+        throw new Error('加密文本和密钥不能为空');
+    }
+
+    try {
+        const decrypted = CryptoJS.AES.decrypt(encryptedText, key);
+        return decrypted.toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+        throw new Error(`解密失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 使用PBKDF2派生密钥
+ */
+export function deriveKey(password: string, salt: string, iterations: number = 10000): string {
+    if (!password || !salt) {
+        throw new Error('密码和盐值不能为空');
+    }
+
+    try {
+        const key = CryptoJS.PBKDF2(password, salt, {
+            keySize: KEY_SIZE / 32,
+            iterations: iterations
+        });
+        return key.toString();
+    } catch (error) {
+        throw new Error(`密钥派生失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 生成加密盐值
+ */
+export function generateSalt(): string {
+    return CryptoJS.lib.WordArray.random(128 / 8).toString();
+}
+
+/**
+ * 安全的哈希函数
+ */
+export function hash(text: string, salt?: string): string {
+    if (!text) {
+        throw new Error('文本不能为空');
+    }
+
+    try {
+        const data = salt ? text + salt : text;
+        return CryptoJS.SHA256(data).toString();
+    } catch (error) {
+        throw new Error(`哈希失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 验证哈希值
+ */
+export function verifyHash(text: string, hashValue: string, salt?: string): boolean {
+    try {
+        const computedHash = hash(text, salt);
+        return computedHash === hashValue;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * 加密对象
+ */
+export function encryptObject(obj: any, key: string): string {
+    if (!obj || !key) {
+        throw new Error('对象和密钥不能为空');
+    }
+
+    try {
+        const jsonString = JSON.stringify(obj);
+        return encrypt(jsonString, key);
+    } catch (error) {
+        throw new Error(`对象加密失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 解密对象
+ */
+export function decryptObject<T>(encryptedText: string, key: string): T {
+    if (!encryptedText || !key) {
+        throw new Error('加密文本和密钥不能为空');
+    }
+
+    try {
+        const jsonString = decrypt(encryptedText, key);
+        return JSON.parse(jsonString) as T;
+    } catch (error) {
+        throw new Error(`对象解密失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 生成令牌
+ */
+export function generateToken(length: number = 32): string {
+    return CryptoJS.lib.WordArray.random(length).toString();
+}
+
+/**
+ * Base64编码
+ */
+export function base64Encode(text: string): string {
+    if (!text) {
+        throw new Error('文本不能为空');
+    }
+
+    try {
+        return CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(text));
+    } catch (error) {
+        throw new Error(`Base64编码失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * Base64解码
+ */
+export function base64Decode(encodedText: string): string {
+    if (!encodedText) {
+        throw new Error('编码文本不能为空');
+    }
+
+    try {
+        return CryptoJS.enc.Base64.parse(encodedText).toString(CryptoJS.enc.Utf8);
+    } catch (error) {
+        throw new Error(`Base64解码失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 安全地比较两个字符串（防止时序攻击）
+ */
+export function secureCompare(a: string, b: string): boolean {
+    if (a.length !== b.length) {
+        return false;
+    }
+
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a.charCodeAt(i) ^ b.charCodeAt(i);
+    }
+
+    return result === 0;
+}
+
+/**
+ * 清除敏感数据
+ */
+export function clearSensitiveData(obj: any): void {
+    if (!obj) return;
+
+    const sensitiveKeys = ['password', 'apiKey', 'token', 'secret', 'key', 'credential'];
+
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const lowerKey = key.toLowerCase();
+
+            if (sensitiveKeys.some(sensitive => lowerKey.includes(sensitive))) {
+                obj[key] = '********';
+            } else if (typeof obj[key] === 'object') {
+                clearSensitiveData(obj[key]);
+            }
+        }
+    }
+}
+
+/**
+ * 生成加密的配置对象
+ */
+export function createSecureConfig(data: any, masterPassword: string): { encrypted: string; salt: string } {
+    if (!data || !masterPassword) {
+        throw new Error('数据和主密码不能为空');
+    }
+
+    const salt = generateSalt();
+    const key = deriveKey(masterPassword, salt);
+    const encrypted = encryptObject(data, key);
+
+    return { encrypted, salt };
+}
+
+/**
+ * 解密配置对象
+ */
+export function parseSecureConfig(encryptedData: string, salt: string, masterPassword: string): any {
+    if (!encryptedData || !salt || !masterPassword) {
+        throw new Error('加密数据、盐值和主密码不能为空');
+    }
+
+    const key = deriveKey(masterPassword, salt);
+    return decryptObject(encryptedData, key);
+}
+
+/**
+ * 检查密码强度并生成哈希
+ */
+export function hashPassword(password: string, salt?: string): { hash: string; salt: string; valid: boolean } {
+    if (!password) {
+        return { hash: '', salt: '', valid: false };
+    }
+
+    const passwordSalt = salt || generateSalt();
+    const passwordHash = hash(password, passwordSalt);
+
+    return {
+        hash: passwordHash,
+        salt: passwordSalt,
+        valid: password.length >= 8
+    };
+}
+
+/**
+ * 验证密码
+ */
+export function verifyPassword(password: string, hash: string, salt: string): boolean {
+    if (!password || !hash || !salt) {
+        return false;
+    }
+
+    return verifyHash(password, hash, salt);
+}

package/src/utils/formatting.utils.ts

@@ -0,0 +1,359 @@
+/**
+ * 格式化工具类
+ * 提供各种数据格式化功能
+ */
+
+/**
+ * 格式化文件大小
+ */
+export function formatFileSize(bytes: number, decimals: number = 2): string {
+    if (bytes === 0) return '0 Bytes';
+
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+
+/**
+ * 格式化持续时间
+ */
+export function formatDuration(milliseconds: number): string {
+    if (milliseconds < 1000) {
+        return `${milliseconds}ms`;
+    }
+
+    const seconds = Math.floor(milliseconds / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    } else {
+        return `${seconds}s`;
+    }
+}
+
+/**
+ * 格式化日期
+ */
+export function formatDate(date: Date, format: 'short' | 'long' | 'relative' = 'short'): string {
+    if (!date) return '';
+
+    switch (format) {
+        case 'short':
+            return date.toLocaleDateString();
+        case 'long':
+            return date.toLocaleString();
+        case 'relative':
+            return formatRelativeTime(date);
+        default:
+            return date.toLocaleDateString();
+    }
+}
+
+/**
+ * 格式化相对时间
+ */
+function formatRelativeTime(date: Date): string {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (seconds < 60) {
+        return '刚刚';
+    } else if (minutes < 60) {
+        return `${minutes}分钟前`;
+    } else if (hours < 24) {
+        return `${hours}小时前`;
+    } else if (days < 7) {
+        return `${days}天前`;
+    } else {
+        return date.toLocaleDateString();
+    }
+}
+
+/**
+ * 格式化数字
+ */
+export function formatNumber(num: number, decimals: number = 0): string {
+    if (isNaN(num)) return '0';
+
+    return num.toLocaleString(undefined, {
+        minimumFractionDigits: decimals,
+        maximumFractionDigits: decimals
+    });
+}
+
+/**
+ * 格式化百分比
+ */
+export function formatPercentage(value: number, total: number, decimals: number = 1): string {
+    if (total === 0) return '0%';
+
+    const percentage = (value / total) * 100;
+    return `${percentage.toFixed(decimals)}%`;
+}
+
+/**
+ * 格式化令牌数量
+ */
+export function formatTokens(tokens: number): string {
+    if (tokens < 1000) {
+        return `${tokens} tokens`;
+    } else if (tokens < 1000000) {
+        return `${(tokens / 1000).toFixed(1)}K tokens`;
+    } else {
+        return `${(tokens / 1000000).toFixed(1)}M tokens`;
+    }
+}
+
+/**
+ * 格式化价格
+ */
+export function formatPrice(amount: number, currency: string = 'USD'): string {
+    return new Intl.NumberFormat(undefined, {
+        style: 'currency',
+        currency
+    }).format(amount);
+}
+
+/**
+ * 格式化命令输出（添加语法高亮）
+ */
+export function formatCommandOutput(output: string): string {
+    // 简单的语法高亮
+    return output
+        .replace(/(\b(?:error|ERROR|Error)\b)/g, '<span class="text-danger">$1</span>')
+        .replace(/(\b(?:warning|WARNING|Warning)\b)/g, '<span class="text-warning">$1</span>')
+        .replace(/(\b(?:success|SUCCESS|Success)\b)/g, '<span class="text-success">$1</span>')
+        .replace(/(\`[^\`]+\`)/g, '<code>$1</code>')
+        .replace(/\n/g, '<br>');
+}
+
+/**
+ * 格式化风险级别
+ */
+export function formatRiskLevel(level: string): { text: string; class: string } {
+    switch (level.toLowerCase()) {
+        case 'low':
+            return { text: '低风险', class: 'text-success' };
+        case 'medium':
+            return { text: '中风险', class: 'text-warning' };
+        case 'high':
+            return { text: '高风险', class: 'text-danger' };
+        case 'critical':
+            return { text: '极风险', class: 'text-danger' };
+        default:
+            return { text: '未知', class: 'text-muted' };
+    }
+}
+
+/**
+ * 格式化置信度
+ */
+export function formatConfidence(confidence: number): { text: string; class: string } {
+    const percentage = Math.round(confidence * 100);
+
+    if (percentage >= 90) {
+        return { text: `${percentage}% - 很高`, class: 'text-success' };
+    } else if (percentage >= 70) {
+        return { text: `${percentage}% - 高`, class: 'text-info' };
+    } else if (percentage >= 50) {
+        return { text: `${percentage}% - 中`, class: 'text-warning' };
+    } else {
+        return { text: `${percentage}% - 低`, class: 'text-danger' };
+    }
+}
+
+/**
+ * 截断文本
+ */
+export function truncateText(text: string, maxLength: number, suffix: string = '...'): string {
+    if (!text || text.length <= maxLength) {
+        return text || '';
+    }
+
+    return text.substring(0, maxLength - suffix.length) + suffix;
+}
+
+/**
+ * 格式化错误信息
+ */
+export function formatError(error: Error | string): string {
+    if (!error) return '未知错误';
+
+    if (typeof error === 'string') {
+        return error;
+    }
+
+    const message = error.message || '未知错误';
+    const stack = error.stack;
+
+    // 如果是API错误，尝试解析
+    if (message.includes('API') || message.includes('HTTP')) {
+        return `API错误: ${message}`;
+    }
+
+    return stack ? `${message}\n${stack}` : message;
+}
+
+/**
+ * 格式化字节数组
+ */
+export function formatBytes(bytes: number[], separator: string = ' '): string {
+    return bytes.map(b => b.toString(16).padStart(2, '0')).join(separator);
+}
+
+/**
+ * 格式化JSON（美化输出）
+ */
+export function formatJson(json: string | object, indent: number = 2): string {
+    try {
+        const obj = typeof json === 'string' ? JSON.parse(json) : json;
+        return JSON.stringify(obj, null, indent);
+    } catch {
+        return typeof json === 'string' ? json : String(json);
+    }
+}
+
+/**
+ * 格式化速度（bytes per second）
+ */
+export function formatSpeed(bytesPerSecond: number): string {
+    if (bytesPerSecond < 1024) {
+        return `${bytesPerSecond.toFixed(2)} B/s`;
+    } else if (bytesPerSecond < 1024 * 1024) {
+        return `${(bytesPerSecond / 1024).toFixed(2)} KB/s`;
+    } else if (bytesPerSecond < 1024 * 1024 * 1024) {
+        return `${(bytesPerSecond / (1024 * 1024)).toFixed(2)} MB/s`;
+    } else {
+        return `${(bytesPerSecond / (1024 * 1024 * 1024)).toFixed(2)} GB/s`;
+    }
+}
+
+/**
+ * 格式化进度条
+ */
+export function formatProgressBar(current: number, total: number, width: number = 20): string {
+    if (total === 0) return '[' + ' '.repeat(width) + '] 0%';
+
+    const percentage = current / total;
+    const filled = Math.round(percentage * width);
+    const empty = width - filled;
+
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    const percent = Math.round(percentage * 100);
+
+    return `[${bar}] ${percent}%`;
+}
+
+/**
+ * 格式化文件路径（显示简化版本）
+ */
+export function formatFilePath(path: string, maxLength: number = 50): string {
+    if (!path || path.length <= maxLength) {
+        return path;
+    }
+
+    const parts = path.split(/[\\/]/);
+    if (parts.length <= 2) {
+        return '...' + path.substring(path.length - maxLength + 3);
+    }
+
+    const first = parts[0];
+    const last = parts[parts.length - 1];
+    const second = parts[1];
+
+    return `${first}/${second}/.../${last}`;
+}
+
+/**
+ * 格式化列表为文本
+ */
+export function formatList(items: string[], delimiter: string = ', '): string {
+    if (!items || items.length === 0) {
+        return '';
+    }
+
+    if (items.length === 1) {
+        return items[0];
+    }
+
+    if (items.length === 2) {
+        return `${items[0]} 和 ${items[1]}`;
+    }
+
+    return items.slice(0, -1).join(delimiter) + '、以及 ' + items[items.length - 1];
+}
+
+/**
+ * 格式化代码块
+ */
+export function formatCodeBlock(code: string, language: string = 'text'): string {
+    return '```' + language + '\n' + code + '\n```';
+}
+
+/**
+ * 转义HTML
+ */
+export function escapeHtml(text: string): string {
+    const map: { [key: string]: string } = {
+        '&': '&amp;',
+        '<': '&lt;',
+        '>': '&gt;',
+        '"': '&quot;',
+        "'": '&#039;'
+    };
+
+    return text.replace(/[&<>"']/g, m => map[m]);
+}
+
+/**
+ * 清理文本（移除多余空白）
+ */
+export function cleanText(text: string): string {
+    return text
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+
+/**
+ * 驼峰命名格式化
+ */
+export function toCamelCase(str: string): string {
+    return str
+        .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+            return index === 0 ? word.toLowerCase() : word.toUpperCase();
+        })
+        .replace(/\s+/g, '');
+}
+
+/**
+ * 短横线命名格式化
+ */
+export function toKebabCase(str: string): string {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+
+/**
+ * 下划线命名格式化
+ */
+export function toSnakeCase(str: string): string {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1_$2')
+        .replace(/[\s-]+/g, '_')
+        .toLowerCase();
+}