tabby-ai-assistant 1.0.0

package/src/services/providers/openai-provider.service.ts

@@ -0,0 +1,376 @@
+import { Injectable } from '@angular/core';
+import axios, { AxiosInstance } from 'axios';
+import { BaseAiProvider } from './base-provider.service';
+import { ProviderCapability, HealthStatus, ValidationResult } from '../../types/provider.types';
+import { ChatRequest, ChatResponse, CommandRequest, CommandResponse, ExplainRequest, ExplainResponse, AnalysisRequest, AnalysisResponse, MessageRole } from '../../types/ai.types';
+import { LoggerService } from '../core/logger.service';
+
+/**
+ * OpenAI AI提供商
+ * 基于OpenAI API格式
+ */
+@Injectable()
+export class OpenAiProviderService extends BaseAiProvider {
+    readonly name = 'openai';
+    readonly displayName = 'OpenAI (GPT-4)';
+    readonly capabilities = [
+        ProviderCapability.CHAT,
+        ProviderCapability.COMMAND_GENERATION,
+        ProviderCapability.COMMAND_EXPLANATION,
+        ProviderCapability.FUNCTION_CALL,
+        ProviderCapability.STREAMING
+    ];
+    readonly authConfig = {
+        type: 'bearer' as const,
+        credentials: {
+            apiKey: ''
+        }
+    };
+
+    private client: AxiosInstance | null = null;
+
+    constructor(logger: LoggerService) {
+        super(logger);
+    }
+
+    configure(config: any): void {
+        super.configure(config);
+        this.authConfig.credentials.apiKey = config.apiKey || '';
+        this.initializeClient();
+    }
+
+    private initializeClient(): void {
+        if (!this.config?.apiKey) {
+            this.logger.warn('OpenAI API key not provided');
+            return;
+        }
+
+        try {
+            this.client = axios.create({
+                baseURL: this.getBaseURL(),
+                timeout: this.getTimeout(),
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            this.logger.info('OpenAI client initialized', {
+                baseURL: this.getBaseURL(),
+                model: this.config.model || 'gpt-4'
+            });
+        } catch (error) {
+            this.logger.error('Failed to initialize OpenAI client', error);
+            throw error;
+        }
+    }
+
+    async chat(request: ChatRequest): Promise<ChatResponse> {
+        if (!this.client) {
+            throw new Error('OpenAI client not initialized');
+        }
+
+        this.logRequest(request);
+
+        try {
+            const response = await this.withRetry(async () => {
+                const result = await this.client!.post('/chat/completions', {
+                    model: this.config?.model || 'gpt-4',
+                    messages: this.transformMessages(request.messages),
+                    max_tokens: request.maxTokens || 1000,
+                    temperature: request.temperature || 0.7,
+                    stream: request.stream || false
+                });
+
+                this.logResponse(result.data);
+                return result.data;
+            });
+
+            return this.transformChatResponse(response);
+
+        } catch (error) {
+            this.logError(error, { request });
+            throw new Error(`OpenAI chat failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+
+    async generateCommand(request: CommandRequest): Promise<CommandResponse> {
+        const prompt = this.buildCommandPrompt(request);
+
+        const chatRequest: ChatRequest = {
+            messages: [
+                {
+                    id: this.generateId(),
+                    role: MessageRole.USER,
+                    content: prompt,
+                    timestamp: new Date()
+                }
+            ],
+            maxTokens: 500,
+            temperature: 0.3
+        };
+
+        const response = await this.chat(chatRequest);
+        return this.parseCommandResponse(response.message.content);
+    }
+
+    async explainCommand(request: ExplainRequest): Promise<ExplainResponse> {
+        const prompt = this.buildExplainPrompt(request);
+
+        const chatRequest: ChatRequest = {
+            messages: [
+                {
+                    id: this.generateId(),
+                    role: MessageRole.USER,
+                    content: prompt,
+                    timestamp: new Date()
+                }
+            ],
+            maxTokens: 1000,
+            temperature: 0.5
+        };
+
+        const response = await this.chat(chatRequest);
+        return this.parseExplainResponse(response.message.content);
+    }
+
+    async analyzeResult(request: AnalysisRequest): Promise<AnalysisResponse> {
+        const prompt = this.buildAnalysisPrompt(request);
+
+        const chatRequest: ChatRequest = {
+            messages: [
+                {
+                    id: this.generateId(),
+                    role: MessageRole.USER,
+                    content: prompt,
+                    timestamp: new Date()
+                }
+            ],
+            maxTokens: 1000,
+            temperature: 0.7
+        };
+
+        const response = await this.chat(chatRequest);
+        return this.parseAnalysisResponse(response.message.content);
+    }
+
+    async healthCheck(): Promise<HealthStatus> {
+        try {
+            if (!this.client) {
+                return HealthStatus.UNHEALTHY;
+            }
+
+            const response = await this.client.post('/chat/completions', {
+                model: this.config?.model || 'gpt-4',
+                max_tokens: 1,
+                messages: [
+                    {
+                        role: 'user',
+                        content: 'Hi'
+                    }
+                ]
+            });
+
+            if (response.status === 200) {
+                this.lastHealthCheck = { status: HealthStatus.HEALTHY, timestamp: new Date() };
+                return HealthStatus.HEALTHY;
+            }
+
+            return HealthStatus.DEGRADED;
+
+        } catch (error) {
+            this.logger.error('OpenAI health check failed', error);
+            this.lastHealthCheck = { status: HealthStatus.UNHEALTHY, timestamp: new Date() };
+            return HealthStatus.UNHEALTHY;
+        }
+    }
+
+    validateConfig(): ValidationResult {
+        const result = super.validateConfig();
+
+        if (!this.config?.apiKey) {
+            return {
+                valid: false,
+                errors: [...(result.errors || []), 'OpenAI API key is required']
+            };
+        }
+
+        const supportedModels = ['gpt-4', 'gpt-4-turbo', 'gpt-3.5-turbo'];
+        if (this.config.model && !supportedModels.includes(this.config.model)) {
+            result.warnings = [
+                ...(result.warnings || []),
+                `Model ${this.config.model} might not be supported. Supported models: ${supportedModels.join(', ')}`
+            ];
+        }
+
+        return result;
+    }
+
+    protected getDefaultBaseURL(): string {
+        return 'https://api.openai.com/v1';
+    }
+
+    protected transformMessages(messages: any[]): any[] {
+        return messages.map(msg => ({
+            role: msg.role,
+            content: msg.content
+        }));
+    }
+
+    private transformChatResponse(response: any): ChatResponse {
+        const choice = response.choices?.[0];
+        const content = choice?.message?.content || '';
+
+        return {
+            message: {
+                id: this.generateId(),
+                role: MessageRole.ASSISTANT,
+                content,
+                timestamp: new Date()
+            },
+            usage: response.usage ? {
+                promptTokens: response.usage.prompt_tokens || 0,
+                completionTokens: response.usage.completion_tokens || 0,
+                totalTokens: response.usage.total_tokens || 0
+            } : undefined
+        };
+    }
+
+    private buildCommandPrompt(request: CommandRequest): string {
+        let prompt = `请将以下自然语言描述转换为准确的终端命令：\n\n"${request.naturalLanguage}"\n\n`;
+
+        if (request.context) {
+            prompt += `当前环境：\n`;
+            if (request.context.currentDirectory) {
+                prompt += `- 当前目录：${request.context.currentDirectory}\n`;
+            }
+            if (request.context.operatingSystem) {
+                prompt += `- 操作系统：${request.context.operatingSystem}\n`;
+            }
+            if (request.context.shell) {
+                prompt += `- Shell：${request.context.shell}\n`;
+            }
+        }
+
+        prompt += `\n请直接返回JSON格式：\n`;
+        prompt += `{\n`;
+        prompt += `  "command": "具体命令",\n`;
+        prompt += `  "explanation": "命令解释",\n`;
+        prompt += `  "confidence": 0.95\n`;
+        prompt += `}\n`;
+
+        return prompt;
+    }
+
+    private buildExplainPrompt(request: ExplainRequest): string {
+        let prompt = `请详细解释以下终端命令：\n\n\`${request.command}\`\n\n`;
+
+        if (request.context?.currentDirectory) {
+            prompt += `当前目录：${request.context.currentDirectory}\n`;
+        }
+        if (request.context?.operatingSystem) {
+            prompt += `操作系统：${request.context.operatingSystem}\n`;
+        }
+
+        prompt += `\n请按以下JSON格式返回：\n`;
+        prompt += `{\n`;
+        prompt += `  "explanation": "整体解释",\n`;
+        prompt += `  "breakdown": [\n`;
+        prompt += `    {"part": "命令部分", "description": "说明"}\n`;
+        prompt += `  ],\n`;
+        prompt += `  "examples": ["使用示例"]\n`;
+        prompt += `}\n`;
+
+        return prompt;
+    }
+
+    private buildAnalysisPrompt(request: AnalysisRequest): string {
+        let prompt = `请分析以下命令执行结果：\n\n`;
+        prompt += `命令：${request.command}\n`;
+        prompt += `退出码：${request.exitCode}\n`;
+        prompt += `输出：\n${request.output}\n\n`;
+
+        if (request.context?.workingDirectory) {
+            prompt += `工作目录：${request.context.workingDirectory}\n`;
+        }
+
+        prompt += `\n请按以下JSON格式返回：\n`;
+        prompt += `{\n`;
+        prompt += `  "summary": "结果总结",\n`;
+        prompt += `  "insights": ["洞察1", "洞察2"],\n`;
+        prompt += `  "success": true/false,\n`;
+        prompt += `  "issues": [\n`;
+        prompt += `    {"severity": "warning|error|info", "message": "问题描述", "suggestion": "建议"}\n`;
+        prompt += `  ]\n`;
+        prompt += `}\n`;
+
+        return prompt;
+    }
+
+    private parseCommandResponse(content: string): CommandResponse {
+        try {
+            const match = content.match(/\{[\s\S]*\}/);
+            if (match) {
+                const parsed = JSON.parse(match[0]);
+                return {
+                    command: parsed.command || '',
+                    explanation: parsed.explanation || '',
+                    confidence: parsed.confidence || 0.5
+                };
+            }
+        } catch (error) {
+            this.logger.warn('Failed to parse command response as JSON', error);
+        }
+
+        const lines = content.split('\n').map(l => l.trim()).filter(l => l);
+        return {
+            command: lines[0] || '',
+            explanation: lines.slice(1).join(' ') || 'AI生成的命令',
+            confidence: 0.5
+        };
+    }
+
+    private parseExplainResponse(content: string): ExplainResponse {
+        try {
+            const match = content.match(/\{[\s\S]*\}/);
+            if (match) {
+                const parsed = JSON.parse(match[0]);
+                return {
+                    explanation: parsed.explanation || '',
+                    breakdown: parsed.breakdown || [],
+                    examples: parsed.examples || []
+                };
+            }
+        } catch (error) {
+            this.logger.warn('Failed to parse explain response as JSON', error);
+        }
+
+        return {
+            explanation: content,
+            breakdown: []
+        };
+    }
+
+    private parseAnalysisResponse(content: string): AnalysisResponse {
+        try {
+            const match = content.match(/\{[\s\S]*\}/);
+            if (match) {
+                const parsed = JSON.parse(match[0]);
+                return {
+                    summary: parsed.summary || '',
+                    insights: parsed.insights || [],
+                    success: parsed.success !== false,
+                    issues: parsed.issues || []
+                };
+            }
+        } catch (error) {
+            this.logger.warn('Failed to parse analysis response as JSON', error);
+        }
+
+        return {
+            summary: content,
+            insights: [],
+            success: true
+        };
+    }
+}

package/src/services/security/consent-manager.service.ts

@@ -0,0 +1,332 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import { RiskLevel, StoredConsent } from '../../types/security.types';
+import { LoggerService } from '../core/logger.service';
+
+@Injectable({ providedIn: 'root' })
+export class ConsentManagerService {
+    private readonly CONSENT_KEY_PREFIX = 'ai-assistant-consent-';
+    private readonly DEFAULT_EXPIRY = 30 * 24 * 60 * 60 * 1000; // 30天
+
+    constructor(private logger: LoggerService) {}
+
+    /**
+     * 存储用户同意
+     */
+    async storeConsent(command: string, riskLevel: RiskLevel): Promise<void> {
+        const consent: StoredConsent = {
+            commandHash: this.hashCommand(command),
+            riskLevel,
+            timestamp: Date.now(),
+            expiry: Date.now() + this.DEFAULT_EXPIRY
+        };
+
+        localStorage.setItem(
+            this.CONSENT_KEY_PREFIX + consent.commandHash,
+            JSON.stringify(consent)
+        );
+
+        this.logger.debug('User consent stored', { commandHash: consent.commandHash, riskLevel });
+    }
+
+    /**
+     * 检查是否有用户同意
+     */
+    async hasConsent(command: string, riskLevel: RiskLevel): Promise<boolean> {
+        const hash = this.hashCommand(command);
+        const stored = localStorage.getItem(this.CONSENT_KEY_PREFIX + hash);
+
+        if (!stored) {
+            return false;
+        }
+
+        try {
+            const consent: StoredConsent = JSON.parse(stored);
+
+            // 检查是否过期
+            if (Date.now() > consent.expiry) {
+                localStorage.removeItem(this.CONSENT_KEY_PREFIX + hash);
+                this.logger.debug('Expired consent removed', { commandHash: hash });
+                return false;
+            }
+
+            // 检查风险级别是否匹配
+            const levelMatch = consent.riskLevel === riskLevel;
+            if (!levelMatch) {
+                this.logger.debug('Risk level mismatch', {
+                    stored: consent.riskLevel,
+                    current: riskLevel
+                });
+                return false;
+            }
+
+            this.logger.debug('Valid consent found', { commandHash: hash });
+            return true;
+
+        } catch (error) {
+            this.logger.error('Failed to parse consent', error);
+            return false;
+        }
+    }
+
+    /**
+     * 请求用户同意
+     */
+    async requestConsent(
+        command: string,
+        explanation: string,
+        riskLevel: RiskLevel
+    ): Promise<boolean> {
+        // 显示确认对话框
+        const riskText = this.getRiskLevelText(riskLevel);
+        const message = `此命令为${riskText}风险：
+
+命令: ${command}
+
+解释: ${explanation}
+
+确定要执行此命令吗？`;
+
+        const confirmed = confirm(message);
+
+        if (confirmed) {
+            this.logger.info('User granted consent', { command, riskLevel });
+        } else {
+            this.logger.info('User denied consent', { command, riskLevel });
+        }
+
+        return confirmed;
+    }
+
+    /**
+     * 清除所有同意
+     */
+    async clearAllConsents(): Promise<void> {
+        const keys = Object.keys(localStorage);
+        const consentKeys = keys.filter(key => key.startsWith(this.CONSENT_KEY_PREFIX));
+
+        consentKeys.forEach(key => {
+            localStorage.removeItem(key);
+        });
+
+        this.logger.info('All consents cleared', { count: consentKeys.length });
+    }
+
+    /**
+     * 获取所有同意数量
+     */
+    async getActiveConsentsCount(): Promise<number> {
+        const keys = Object.keys(localStorage);
+        const consentKeys = keys.filter(key => key.startsWith(this.CONSENT_KEY_PREFIX));
+
+        let activeCount = 0;
+        const now = Date.now();
+
+        consentKeys.forEach(key => {
+            try {
+                const consentStr = localStorage.getItem(key);
+                if (consentStr) {
+                    const consent: StoredConsent = JSON.parse(consentStr);
+                    if (now <= consent.expiry) {
+                        activeCount++;
+                    } else {
+                        // 删除过期的
+                        localStorage.removeItem(key);
+                    }
+                }
+            } catch (error) {
+                // 删除损坏的
+                localStorage.removeItem(key);
+            }
+        });
+
+        return activeCount;
+    }
+
+    /**
+     * 获取总验证次数
+     */
+    async getTotalValidations(): Promise<number> {
+        const keys = Object.keys(localStorage);
+        const consentKeys = keys.filter(key => key.startsWith(this.CONSENT_KEY_PREFIX));
+        return consentKeys.length;
+    }
+
+    /**
+     * 获取同意统计
+     */
+    async getConsentStats(): Promise<{
+        total: number;
+        byLevel: { [key in RiskLevel]: number };
+        expired: number;
+    }> {
+        const stats = {
+            total: 0,
+            byLevel: {
+                [RiskLevel.LOW]: 0,
+                [RiskLevel.MEDIUM]: 0,
+                [RiskLevel.HIGH]: 0,
+                [RiskLevel.CRITICAL]: 0
+            },
+            expired: 0
+        };
+
+        const keys = Object.keys(localStorage);
+        const consentKeys = keys.filter(key => key.startsWith(this.CONSENT_KEY_PREFIX));
+        const now = Date.now();
+
+        consentKeys.forEach(key => {
+            try {
+                const consentStr = localStorage.getItem(key);
+                if (consentStr) {
+                    const consent: StoredConsent = JSON.parse(consentStr);
+                    stats.total++;
+
+                    if (now <= consent.expiry) {
+                        stats.byLevel[consent.riskLevel]++;
+                    } else {
+                        stats.expired++;
+                        // 删除过期的
+                        localStorage.removeItem(key);
+                    }
+                }
+            } catch (error) {
+                // 删除损坏的
+                localStorage.removeItem(key);
+            }
+        });
+
+        return stats;
+    }
+
+    /**
+     * 清理过期的同意
+     */
+    async cleanupExpiredConsents(): Promise<number> {
+        const keys = Object.keys(localStorage);
+        const consentKeys = keys.filter(key => key.startsWith(this.CONSENT_KEY_PREFIX));
+        let removedCount = 0;
+        const now = Date.now();
+
+        consentKeys.forEach(key => {
+            try {
+                const consentStr = localStorage.getItem(key);
+                if (consentStr) {
+                    const consent: StoredConsent = JSON.parse(consentStr);
+                    if (now > consent.expiry) {
+                        localStorage.removeItem(key);
+                        removedCount++;
+                    }
+                }
+            } catch (error) {
+                // 删除损坏的
+                localStorage.removeItem(key);
+                removedCount++;
+            }
+        });
+
+        if (removedCount > 0) {
+            this.logger.info('Expired consents cleaned up', { removedCount });
+        }
+
+        return removedCount;
+    }
+
+    /**
+     * 获取风险级别文本
+     */
+    private getRiskLevelText(riskLevel: RiskLevel): string {
+        switch (riskLevel) {
+            case RiskLevel.LOW:
+                return '低';
+            case RiskLevel.MEDIUM:
+                return '中';
+            case RiskLevel.HIGH:
+                return '高';
+            case RiskLevel.CRITICAL:
+                return '极';
+            default:
+                return '未知';
+        }
+    }
+
+    /**
+     * 对命令进行哈希
+     */
+    private hashCommand(command: string): string {
+        // 规范化命令（去除多余空格，转换为小写）
+        const normalized = command.trim().toLowerCase();
+        return CryptoJS.SHA256(normalized).toString();
+    }
+
+    /**
+     * 导出同意数据
+     */
+    exportConsents(): string {
+        const consents: StoredConsent[] = [];
+        const keys = Object.keys(localStorage);
+        const consentKeys = keys.filter(key => key.startsWith(this.CONSENT_KEY_PREFIX));
+
+        consentKeys.forEach(key => {
+            try {
+                const consentStr = localStorage.getItem(key);
+                if (consentStr) {
+                    consents.push(JSON.parse(consentStr));
+                }
+            } catch (error) {
+                // 跳过损坏的数据
+            }
+        });
+
+        return JSON.stringify({
+            exportTime: new Date().toISOString(),
+            consents
+        }, null, 2);
+    }
+
+    /**
+     * 导入同意数据
+     */
+    importConsents(data: string): Promise<{ imported: number; skipped: number }> {
+        return new Promise((resolve, reject) => {
+            try {
+                const parsed = JSON.parse(data);
+                if (!parsed.consents || !Array.isArray(parsed.consents)) {
+                    throw new Error('Invalid data format');
+                }
+
+                let imported = 0;
+                let skipped = 0;
+
+                parsed.consents.forEach((consent: StoredConsent) => {
+                    try {
+                        // 检查是否已存在且未过期
+                        const existing = localStorage.getItem(this.CONSENT_KEY_PREFIX + consent.commandHash);
+                        if (existing) {
+                            const existingConsent: StoredConsent = JSON.parse(existing);
+                            if (Date.now() <= existingConsent.expiry) {
+                                skipped++;
+                                return;
+                            }
+                        }
+
+                        // 导入同意
+                        localStorage.setItem(
+                            this.CONSENT_KEY_PREFIX + consent.commandHash,
+                            JSON.stringify(consent)
+                        );
+                        imported++;
+                    } catch (error) {
+                        skipped++;
+                    }
+                });
+
+                this.logger.info('Consents imported', { imported, skipped });
+                resolve({ imported, skipped });
+
+            } catch (error) {
+                reject(error);
+            }
+        });
+    }
+}