tabby-ai-assistant 1.0.0

package/src/utils/validation.utils.spec.ts

@@ -0,0 +1,225 @@
+import {
+    validateApiKey,
+    validateUrl,
+    validateModel,
+    validateTemperature,
+    validateMaxTokens,
+    validateCommand,
+    validateEmail,
+    validatePassword,
+    validatePort,
+    validateJson,
+    validateFilePath
+} from './validation.utils';
+
+describe('ValidationUtils', () => {
+    describe('validateApiKey', () => {
+        it('should validate OpenAI API keys', () => {
+            const result = validateApiKey('sk-test123456789', 'openai');
+            expect(result.valid).toBe(true);
+
+            const invalidResult = validateApiKey('invalid-key', 'openai');
+            expect(invalidResult.valid).toBe(false);
+            expect(invalidResult.error).toContain('sk-');
+        });
+
+        it('should validate Anthropic API keys', () => {
+            const result = validateApiKey('sk-ant-test123456789', 'anthropic');
+            expect(result.valid).toBe(true);
+
+            const invalidResult = validateApiKey('invalid-key', 'anthropic');
+            expect(invalidResult.valid).toBe(false);
+            expect(invalidResult.error).toContain('sk-ant-');
+        });
+
+        it('should validate Minimax API keys', () => {
+            const result = validateApiKey('minimax-key-123456789', 'minimax');
+            expect(result.valid).toBe(true);
+
+            const invalidResult = validateApiKey('short', 'minimax');
+            expect(invalidResult.valid).toBe(false);
+        });
+
+        it('should validate GLM API keys', () => {
+            const result = validateApiKey('glm-key-123456789', 'glm');
+            expect(result.valid).toBe(true);
+        });
+
+        it('should accept empty keys for compatible provider', () => {
+            const result = validateApiKey('', 'openai-compatible');
+            expect(result.valid).toBe(true);
+        });
+    });
+
+    describe('validateUrl', () => {
+        it('should validate correct URLs', () => {
+            const result = validateUrl('https://api.example.com');
+            expect(result.valid).toBe(true);
+
+            const result2 = validateUrl('http://localhost:11434');
+            expect(result2.valid).toBe(true);
+        });
+
+        it('should reject invalid URLs', () => {
+            const result = validateUrl('not-a-url');
+            expect(result.valid).toBe(false);
+            expect(result.error).toContain('URL');
+
+            const result2 = validateUrl('ftp://example.com');
+            expect(result2.valid).toBe(false);
+            expect(result2.error).toContain('HTTP');
+        });
+
+        it('should reject empty URLs', () => {
+            const result = validateUrl('');
+            expect(result.valid).toBe(false);
+        });
+    });
+
+    describe('validateModel', () => {
+        it('should validate correct model names', () => {
+            const result = validateModel('gpt-4', 'openai');
+            expect(result.valid).toBe(true);
+
+            const result2 = validateModel('claude-3-sonnet', 'anthropic');
+            expect(result2.valid).toBe(true);
+        });
+
+        it('should reject invalid model names', () => {
+            const result = validateModel('', 'openai');
+            expect(result.valid).toBe(false);
+
+            const result2 = validateModel('model@#$%', 'openai');
+            expect(result2.valid).toBe(false);
+        });
+    });
+
+    describe('validateTemperature', () => {
+        it('should validate correct temperature values', () => {
+            expect(validateTemperature(0).valid).toBe(true);
+            expect(validateTemperature(0.7).valid).toBe(true);
+            expect(validateTemperature(1.5).valid).toBe(true);
+            expect(validateTemperature(2).valid).toBe(true);
+        });
+
+        it('should reject invalid temperature values', () => {
+            expect(validateTemperature(-0.1).valid).toBe(false);
+            expect(validateTemperature(2.1).valid).toBe(false);
+            expect(validateTemperature(NaN).valid).toBe(false);
+        });
+    });
+
+    describe('validateMaxTokens', () => {
+        it('should validate correct token values', () => {
+            expect(validateMaxTokens(100).valid).toBe(true);
+            expect(validateMaxTokens(1000).valid).toBe(true);
+            expect(validateMaxTokens(32000).valid).toBe(true);
+        });
+
+        it('should reject invalid token values', () => {
+            expect(validateMaxTokens(0).valid).toBe(false);
+            expect(validateMaxTokens(-100).valid).toBe(false);
+            expect(validateMaxTokens(32001).valid).toBe(false);
+        });
+    });
+
+    describe('validateCommand', () => {
+        it('should accept safe commands', () => {
+            expect(validateCommand('ls -la').valid).toBe(true);
+            expect(validateCommand('git status').valid).toBe(true);
+            expect(validateCommand('echo "hello world"').valid).toBe(true);
+        });
+
+        it('should reject dangerous commands', () => {
+            expect(validateCommand('rm -rf /').valid).toBe(false);
+            expect(validateCommand('sudo rm -rf /home').valid).toBe(false);
+            expect(validateCommand('chmod 777 /etc/passwd').valid).toBe(false);
+            expect(validateCommand('dd if=/dev/zero of=/dev/sda').valid).toBe(false);
+        });
+
+        it('should reject commands with injection attempts', () => {
+            expect(validateCommand('ls; rm -rf /').valid).toBe(false);
+            expect(validateCommand('cat file | sh').valid).toBe(false);
+            expect(validateCommand('$(rm -rf /)').valid).toBe(false);
+        });
+    });
+
+    describe('validateEmail', () => {
+        it('should validate correct email addresses', () => {
+            expect(validateEmail('test@example.com').valid).toBe(true);
+            expect(validateEmail('user.name@domain.co.uk').valid).toBe(true);
+        });
+
+        it('should reject invalid email addresses', () => {
+            expect(validateEmail('invalid').valid).toBe(false);
+            expect(validateEmail('@example.com').valid).toBe(false);
+            expect(validateEmail('test@').valid).toBe(false);
+        });
+    });
+
+    describe('validatePassword', () => {
+        it('should validate strong passwords', () => {
+            const result = validatePassword('SecurePass123!');
+            expect(result.valid).toBe(true);
+            expect(result.score).toBeGreaterThan(40);
+        });
+
+        it('should reject weak passwords', () => {
+            expect(validatePassword('weak').valid).toBe(false);
+            expect(validatePassword('password').valid).toBe(false);
+            expect(validatePassword('123456').valid).toBe(false);
+        });
+
+        it('should score passwords correctly', () => {
+            const weak = validatePassword('123');
+            expect(weak.score).toBe(0);
+
+            const medium = validatePassword('password123');
+            expect(medium.score).toBeGreaterThan(0);
+            expect(medium.score).toBeLessThan(50);
+
+            const strong = validatePassword('StrongPass123!');
+            expect(strong.score).toBeGreaterThan(60);
+        });
+    });
+
+    describe('validatePort', () => {
+        it('should validate correct ports', () => {
+            expect(validatePort(80).valid).toBe(true);
+            expect(validatePort(443).valid).toBe(true);
+            expect(validatePort(3000).valid).toBe(true);
+            expect(validatePort(65535).valid).toBe(true);
+        });
+
+        it('should reject invalid ports', () => {
+            expect(validatePort(0).valid).toBe(false);
+            expect(validatePort(65536).valid).toBe(false);
+            expect(validatePort(-1).valid).toBe(false);
+        });
+    });
+
+    describe('validateJson', () => {
+        it('should validate correct JSON', () => {
+            const result = validateJson('{"key": "value"}');
+            expect(result.valid).toBe(true);
+            expect(result.data).toEqual({ key: 'value' });
+        });
+
+        it('should reject invalid JSON', () => {
+            const result = validateJson('{invalid json}');
+            expect(result.valid).toBe(false);
+        });
+    });
+
+    describe('validateFilePath', () => {
+        it('should validate correct file paths', () => {
+            expect(validateFilePath('/home/user/file.txt').valid).toBe(true);
+            expect(validateFilePath('C:\\Windows\\System32').valid).toBe(true);
+        });
+
+        it('should reject invalid file paths', () => {
+            expect(validateFilePath('').valid).toBe(false);
+            expect(validateFilePath('path<with>invalid').valid).toBe(false);
+        });
+    });
+});

package/src/utils/validation.utils.ts

@@ -0,0 +1,314 @@
+/**
+ * 验证工具类
+ * 提供各种数据验证和格式检查功能
+ */
+
+/**
+ * 验证API密钥格式
+ */
+export function validateApiKey(apiKey: string, provider: string): { valid: boolean; error?: string } {
+    if (!apiKey || apiKey.trim().length === 0) {
+        return { valid: false, error: 'API密钥不能为空' };
+    }
+
+    // 移除前后空格
+    const trimmedKey = apiKey.trim();
+
+    // 根据提供商验证格式
+    switch (provider.toLowerCase()) {
+        case 'openai':
+            return validateOpenAiKey(trimmedKey);
+        case 'anthropic':
+            return validateAnthropicKey(trimmedKey);
+        case 'minimax':
+            return validateMinimaxKey(trimmedKey);
+        case 'glm':
+            return validateGlmKey(trimmedKey);
+        case 'openai-compatible':
+            return { valid: true };
+        default:
+            return { valid: true };
+    }
+}
+
+/**
+ * 验证OpenAI API密钥格式
+ */
+function validateOpenAiKey(key: string): { valid: boolean; error?: string } {
+    // OpenAI密钥通常以 sk- 开头
+    if (!key.startsWith('sk-')) {
+        return { valid: false, error: 'OpenAI API密钥应以 sk- 开头' };
+    }
+
+    if (key.length < 50) {
+        return { valid: false, error: 'OpenAI API密钥长度不足' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证Anthropic API密钥格式
+ */
+function validateAnthropicKey(key: string): { valid: boolean; error?: string } {
+    // Anthropic密钥通常以 sk-ant- 开头
+    if (!key.startsWith('sk-ant-')) {
+        return { valid: false, error: 'Anthropic API密钥应以 sk-ant- 开头' };
+    }
+
+    if (key.length < 50) {
+        return { valid: false, error: 'Anthropic API密钥长度不足' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证Minimax API密钥格式
+ */
+function validateMinimaxKey(key: string): { valid: boolean; error?: string } {
+    // Minimax密钥长度检查
+    if (key.length < 20) {
+        return { valid: false, error: 'Minimax API密钥长度不足' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证GLM API密钥格式
+ */
+function validateGlmKey(key: string): { valid: boolean; error?: string } {
+    // GLM密钥长度检查
+    if (key.length < 20) {
+        return { valid: false, error: 'GLM API密钥长度不足' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证URL格式
+ */
+export function validateUrl(url: string): { valid: boolean; error?: string } {
+    if (!url || url.trim().length === 0) {
+        return { valid: false, error: 'URL不能为空' };
+    }
+
+    try {
+        const parsedUrl = new URL(url);
+        if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+            return { valid: false, error: 'URL必须使用HTTP或HTTPS协议' };
+        }
+        return { valid: true };
+    } catch {
+        return { valid: false, error: '无效的URL格式' };
+    }
+}
+
+/**
+ * 验证模型名称
+ */
+export function validateModel(model: string, _provider: string): { valid: boolean; error?: string } {
+    if (!model || model.trim().length === 0) {
+        return { valid: false, error: '模型名称不能为空' };
+    }
+
+    const trimmedModel = model.trim();
+
+    // 验证模型名称格式
+    if (!/^[a-zA-Z0-9._-]+$/.test(trimmedModel)) {
+        return { valid: false, error: '模型名称包含非法字符' };
+    }
+
+    // TODO: 根据提供商类型进行特定验证
+    // _provider 参数保留用于未来扩展
+
+    return { valid: true };
+}
+
+/**
+ * 验证温度参数
+ */
+export function validateTemperature(temperature: number): { valid: boolean; error?: string } {
+    if (typeof temperature !== 'number' || isNaN(temperature)) {
+        return { valid: false, error: '温度必须是有效数字' };
+    }
+
+    if (temperature < 0 || temperature > 2) {
+        return { valid: false, error: '温度值必须在0-2之间' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证最大令牌数
+ */
+export function validateMaxTokens(maxTokens: number): { valid: boolean; error?: string } {
+    if (typeof maxTokens !== 'number' || isNaN(maxTokens) || maxTokens <= 0) {
+        return { valid: false, error: '最大令牌数必须是正整数' };
+    }
+
+    if (maxTokens > 32000) {
+        return { valid: false, error: '最大令牌数不能超过32000' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证命令字符串
+ */
+export function validateCommand(command: string): { valid: boolean; error?: string } {
+    if (!command || command.trim().length === 0) {
+        return { valid: false, error: '命令不能为空' };
+    }
+
+    const trimmed = command.trim();
+
+    // 检查危险模式
+    const dangerousPatterns = [
+        /rm\s+-rf\s+\//,
+        /sudo\s+rm/,
+        />\s*\/dev\/null/,
+        /chmod\s+777/,
+        /dd\s+if=/,
+        /fork\s*\(/,
+        /\|\s*sh\b/,
+        /\|\s*bash\b/,
+        /\$\(/,
+        /`[^`]*`/,
+        /;\s*rm/,
+        /&&\s*rm/
+    ];
+
+    for (const pattern of dangerousPatterns) {
+        if (pattern.test(trimmed)) {
+            return { valid: false, error: '检测到潜在危险命令' };
+        }
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证邮箱格式
+ */
+export function validateEmail(email: string): { valid: boolean; error?: string } {
+    if (!email || email.trim().length === 0) {
+        return { valid: false, error: '邮箱不能为空' };
+    }
+
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(email)) {
+        return { valid: false, error: '邮箱格式无效' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证密码强度
+ */
+export function validatePassword(password: string): { valid: boolean; error?: string; score: number } {
+    if (!password || password.length === 0) {
+        return { valid: false, error: '密码不能为空', score: 0 };
+    }
+
+    let score = 0;
+    const errors: string[] = [];
+
+    // 长度检查
+    if (password.length < 8) {
+        errors.push('密码至少需要8个字符');
+    } else {
+        score += 20;
+    }
+
+    if (password.length >= 12) {
+        score += 10;
+    }
+
+    // 字符类型检查
+    const hasLower = /[a-z]/.test(password);
+    const hasUpper = /[A-Z]/.test(password);
+    const hasNumber = /\d/.test(password);
+    const hasSpecial = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password);
+
+    if (hasLower) score += 10;
+    if (hasUpper) score += 10;
+    if (hasNumber) score += 10;
+    if (hasSpecial) score += 10;
+
+    if (!hasLower) errors.push('需要包含小写字母');
+    if (!hasUpper) errors.push('需要包含大写字母');
+    if (!hasNumber) errors.push('需要包含数字');
+    if (!hasSpecial) errors.push('需要包含特殊字符');
+
+    // 常见密码检查
+    const commonPasswords = ['password', '123456', 'qwerty', 'admin', 'letmein'];
+    if (commonPasswords.includes(password.toLowerCase())) {
+        return { valid: false, error: '密码过于常见', score: 0 };
+    }
+
+    const valid = errors.length === 0 && score >= 40;
+    return {
+        valid,
+        error: valid ? undefined : errors.join(', '),
+        score: Math.min(score, 100)
+    };
+}
+
+/**
+ * 验证端口号
+ */
+export function validatePort(port: number): { valid: boolean; error?: string } {
+    if (typeof port !== 'number' || isNaN(port) || !Number.isInteger(port)) {
+        return { valid: false, error: '端口必须是整数' };
+    }
+
+    if (port < 1 || port > 65535) {
+        return { valid: false, error: '端口号必须在1-65535之间' };
+    }
+
+    return { valid: true };
+}
+
+/**
+ * 验证JSON格式
+ */
+export function validateJson(jsonString: string): { valid: boolean; error?: string; data?: any } {
+    if (!jsonString || jsonString.trim().length === 0) {
+        return { valid: false, error: 'JSON字符串不能为空' };
+    }
+
+    try {
+        const data = JSON.parse(jsonString);
+        return { valid: true, data };
+    } catch (error) {
+        return { valid: false, error: '无效的JSON格式' };
+    }
+}
+
+/**
+ * 验证文件路径
+ */
+export function validateFilePath(path: string): { valid: boolean; error?: string } {
+    if (!path || path.trim().length === 0) {
+        return { valid: false, error: '文件路径不能为空' };
+    }
+
+    // 检查路径长度
+    if (path.length > 260) {
+        return { valid: false, error: '文件路径过长' };
+    }
+
+    // 检查非法字符
+    const invalidChars = /[<>:"/\\|?*]/;
+    if (invalidChars.test(path)) {
+        return { valid: false, error: '路径包含非法字符' };
+    }
+
+    return { valid: true };
+}

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "commonjs",
+        "lib": ["ES2020", "DOM"],
+        "declaration": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": false,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": false,
+        "noImplicitAny": false,
+        "noImplicitReturns": false,
+        "noImplicitThis": false,
+        "noUnusedLocals": false,
+        "noUnusedParameters": false,
+        "strictNullChecks": false,
+        "strictFunctionTypes": false,
+        "strictBindCallApply": false,
+        "strictPropertyInitialization": false,
+        "noFallthroughCasesInSwitch": false,
+        "moduleResolution": "node",
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": true,
+        "resolveJsonModule": true,
+        "sourceMap": true,
+        "baseUrl": "./",
+        "paths": {
+            "@/*": ["src/*"]
+        },
+        "typeRoots": [
+            "node_modules/@types",
+            "src/types"
+        ]
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.spec.ts"
+    ]
+}

package/webpack-docker.config.js

@@ -0,0 +1,42 @@
+const path = require('path')
+
+module.exports = {
+  target: 'node',
+  entry: 'src/index.ts',
+  devtool: 'source-map',
+  context: __dirname,
+  mode: 'production',
+  output: {
+    path: path.resolve(__dirname, 'dist'),
+    filename: 'index.js',
+    pathinfo: true,
+    libraryTarget: 'umd',
+    devtoolModuleFilenameTemplate: 'webpack-tabby-ai-assistant:///[resource-path]',
+  },
+  resolve: {
+    modules: ['.', 'src', 'node_modules'].map(x => path.join(__dirname, x)),
+    extensions: ['.ts', '.js'],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        loader: 'ts-loader',
+      },
+      {
+        test: /\.scss/,
+        use: ['raw-loader', 'css-loader', 'sass-loader'],
+      },
+      { test: /\.pug$/, use: ['pug-plain-loader'] },
+    ]
+  },
+  externals: [
+    'fs',
+    'ngx-toastr',
+    'util',
+    /^rxjs/,
+    /^@angular/,
+    /^@ng-bootstrap/,
+    /^tabby-/,
+  ]
+}

package/webpack.config.js

@@ -0,0 +1,59 @@
+const path = require('path');
+const webpack = require('webpack');
+
+module.exports = {
+    mode: 'production',
+    entry: './src/index.ts',
+    output: {
+        path: path.resolve(__dirname, 'dist'),
+        filename: 'index.js',
+        library: 'AiAssistantModule',
+        libraryTarget: 'commonjs2',
+        libraryExport: 'default',
+        devtoolModuleFilenameTemplate: 'webpack-tabby-ai-assistant:///[resource-path]',
+    },
+    resolve: {
+        extensions: ['.ts', '.js'],
+        alias: {
+            '@': path.resolve(__dirname, 'src')
+        },
+        fallback: {
+            'os': false,
+            'path': false,
+            'crypto': false,
+            'stream': false,
+            'util': false
+        }
+    },
+    module: {
+        rules: [
+            {
+                test: /\.ts$/,
+                use: [
+                    { loader: 'ts-loader' },
+                    { loader: 'angular2-template-loader' }
+                ],
+                exclude: /node_modules/
+            },
+            {
+                test: /\.(html|css|scss)$/,
+                use: ['raw-loader']
+            }
+        ]
+    },
+    externals: [
+        'tabby-core',
+        'tabby-terminal',
+        'tabby-settings',
+        '@angular/core',
+        '@angular/common',
+        '@angular/forms',
+        '@ng-bootstrap/ng-bootstrap',
+        'rxjs'
+    ],
+    plugins: [
+        new webpack.DefinePlugin({
+            'process.env.NODE_ENV': JSON.stringify('production')
+        })
+    ]
+};