Security Best Practices

import { z } from 'zod'

class SecureTool extends Tool {
  constructor() {
    super({
      name: 'user_profile_update',
      description: 'Update user profile information securely',
      schema: z.object({
        userId: z.string().uuid('Invalid user ID format'),
        updates: z.object({
          name: z.string()
            .min(1, 'Name cannot be empty')
            .max(100, 'Name too long')
            .regex(/^[a-zA-Z\s'-]+$/, 'Name contains invalid characters'),
          email: z.string()
            .email('Invalid email format')
            .transform(email => email.toLowerCase()),
          bio: z.string()
            .max(500, 'Bio too long')
            .optional()
            .transform(bio => this.sanitizeHtml(bio || ''))
        }).refine(
          (updates) => !(updates.name === 'admin' && updates.email?.includes('evil.com')),
          'Suspicious update pattern detected'
        )
      }),
      handler: (args) => this.executeSecurely(args)
    })
  }

  private sanitizeHtml(input: string): string {
    // Remove potentially dangerous HTML/script content
    return input
      .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
      .replace(/<[^>]*>/g, '') // Remove all HTML tags
      .replace(/[\x00-\x1F\x7F-\x9F]/g, '') // Remove control characters
      .trim()
  }

  private async executeSecurely({ userId, updates }) {
    // Verify user permissions
    const currentUser = await this.getCurrentUser()
    if (currentUser.id !== userId && !currentUser.isAdmin) {
      throw new Error('Unauthorized: Cannot update other users profile')
    }

    // Check for rate limiting
    const recentUpdates = await this.getRecentUpdates(userId)
    if (recentUpdates.length > 10) {
      throw new Error('Rate limit exceeded: Too many updates')
    }

    // Use parameterized queries to prevent SQL injection
    const result = await db.user.update({
      where: { id: userId },
      data: {
        ...updates,
        updatedAt: new Date(),
        updatedBy: currentUser.id
      }
    })

    // Log the security event
    await this.logSecurityEvent('profile_update', {
      userId,
      updatedFields: Object.keys(updates),
      ipAddress: this.getClientIP(),
      userAgent: this.getUserAgent()
    })

    return JSON.stringify({
      success: true,
      updatedFields: Object.keys(updates)
    })
  }

  private async getCurrentUser() {
    // Implementation would get user from session/JWT
    return { id: 'current-user-id', isAdmin: false }
  }

  private async getRecentUpdates(userId: string) {
    // Check recent updates for rate limiting
    return await db.userUpdate.findMany({
      where: {
        userId,
        createdAt: { gte: new Date(Date.now() - 3600000) } // Last hour
      }
    })
  }

  private async logSecurityEvent(event: string, data: any) {
    // Log to security monitoring system
    console.log(`SECURITY: ${event}`, data)
  }

  private getClientIP(): string {
    // Implementation would extract from request
    return '127.0.0.1'
  }

  private getUserAgent(): string {
    // Implementation would extract from request
    return 'agent-client/1.0'
  }
}

// Content filtering for user-generated content
const contentSecurityTool = new Tool({
  name: 'moderate_content',
  description: 'Moderate user-generated content for safety',
  schema: z.object({
    content: z.string().max(10000, 'Content too long'),
    contentType: z.enum(['post', 'comment', 'message'])
  }),

  handler: async ({ content, contentType }) => {
    // Multiple security checks
    const checks = await Promise.all([
      this.checkToxicity(content),
      this.checkSpam(content),
      this.checkPersonalInfo(content),
      this.checkMaliciousPatterns(content)
    ])

    const failedChecks = checks.filter(check => !check.passed)

    if (failedChecks.length > 0) {
      // Don't reveal specific failure reasons to prevent probing
      throw new Error('Content violates community guidelines')
    }

    return JSON.stringify({ approved: true })
  }
})

class SecureApiTool extends Tool {
  private jwtSecret: string
  private allowedDomains: Set<string>

  constructor(config: { jwtSecret: string, allowedDomains: string[] }) {
    super({
      name: 'api_call',
      description: 'Make authenticated API calls to external services',
      schema: z.object({
        endpoint: z.string().url(),
        method: z.enum(['GET', 'POST', 'PUT', 'DELETE']),
        body: z.any().optional(),
        headers: z.record(z.string()).optional()
      }),
      handler: (args) => this.executeSecureApiCall(args)
    })

    this.jwtSecret = config.jwtSecret
    this.allowedDomains = new Set(config.allowedDomains)
  }

  private async executeSecureApiCall({ endpoint, method, body, headers = {} }) {
    // Validate domain whitelist
    const url = new URL(endpoint)
    if (!this.allowedDomains.has(url.hostname)) {
      throw new Error(`Domain not allowed: ${url.hostname}`)
    }

    // Generate JWT for this request
    const token = this.generateRequestToken(endpoint, method)

    // Merge headers with security headers
    const secureHeaders = {
      ...headers,
      'Authorization': `Bearer ${token}`,
      'X-Request-ID': this.generateRequestId(),
      'X-API-Key': this.getApiKeyForDomain(url.hostname),
      'User-Agent': 'SecureAgent/1.0'
    }

    // Remove any headers that could be dangerous
    delete secureHeaders['host']
    delete secureHeaders['cookie']

    try {
      const response = await fetch(endpoint, {
        method,
        headers: secureHeaders,
        body: body ? JSON.stringify(body) : undefined,
        // Security timeouts
        signal: AbortSignal.timeout(30000) // 30 second timeout
      })

      // Validate response
      if (!response.ok) {
        throw new Error(`API call failed: ${response.status} ${response.statusText}`)
      }

      const data = await response.json()

      // Log successful API call
      await this.logApiCall(endpoint, method, response.status)

      return JSON.stringify(data)

    } catch (error) {
      // Log failed API call
      await this.logApiCall(endpoint, method, 0, error.message)

      // Don't expose internal error details
      throw new Error('External API call failed')
    }
  }

  private generateRequestToken(endpoint: string, method: string): string {
    // Create a short-lived JWT for this specific request
    const payload = {
      endpoint: endpoint.substring(0, 200), // Limit length
      method,
      timestamp: Date.now(),
      exp: Math.floor(Date.now() / 1000) + 300 // 5 minutes
    }

    return jwt.sign(payload, this.jwtSecret)
  }

  private generateRequestId(): string {
    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
  }

  private getApiKeyForDomain(domain: string): string {
    // Securely retrieve API key for domain
    // In practice, use a secure key management system
    const keys = {
      'api.example.com': process.env.EXAMPLE_API_KEY,
      'secure-api.service.com': process.env.SERVICE_API_KEY
    }

    const key = keys[domain]
    if (!key) {
      throw new Error(`No API key configured for domain: ${domain}`)
    }

    return key
  }

  private async logApiCall(endpoint: string, method: string, status: number, error?: string) {
    // Log to security monitoring
    const logEntry = {
      timestamp: new Date().toISOString(),
      endpoint: endpoint.substring(0, 200),
      method,
      status,
      error: error?.substring(0, 200),
      ip: this.getClientIP()
    }

    console.log('API_CALL:', JSON.stringify(logEntry))
  }

  private getClientIP(): string {
    // Extract from request context
    return '127.0.0.1'
  }
}

// Rate limiting for API calls
class RateLimitedTool extends Tool {
  private requestCounts = new Map<string, { count: number, resetTime: number }>()
  private maxRequestsPerMinute = 60

  constructor(tool: Tool) {
    super(tool)
  }

  async execute(args: any): Promise<string> {
    const clientId = this.getClientIdentifier()
    const now = Date.now()
    const windowStart = Math.floor(now / 60000) * 60000 // 1-minute windows

    const clientRequests = this.requestCounts.get(clientId) || { count: 0, resetTime: windowStart + 60000 }

    // Reset counter if window has passed
    if (now > clientRequests.resetTime) {
      clientRequests.count = 0
      clientRequests.resetTime = windowStart + 60000
    }

    // Check rate limit
    if (clientRequests.count >= this.maxRequestsPerMinute) {
      throw new Error('Rate limit exceeded. Please try again later.')
    }

    // Increment counter
    clientRequests.count++
    this.requestCounts.set(clientId, clientRequests)

    // Execute the actual tool
    return await super.execute(args)
  }

  private getClientIdentifier(): string {
    // Use IP + user ID for rate limiting
    return `${this.getClientIP()}_${this.getUserId()}`
  }

  private getClientIP(): string { return '127.0.0.1' }
  private getUserId(): string { return 'anonymous' }
}

import { VM } from 'vm2' // Secure sandbox library

class SandboxedCodeTool extends Tool {
  constructor() {
    super({
      name: 'execute_code',
      description: 'Execute user-provided code in a secure sandbox',
      schema: z.object({
        code: z.string()
          .max(1000, 'Code too long')
          .refine(code => !code.includes('require('), 'External modules not allowed')
          .refine(code => !code.includes('process'), 'Process access not allowed')
          .refine(code => !code.includes('fs'), 'File system access not allowed'),
        timeout: z.number().min(100).max(5000).default(1000)
      }),
      handler: (args) => this.executeSandboxedCode(args)
    })
  }

  private async executeSandboxedCode({ code, timeout }) {
    // Pre-execution security checks
    if (this.containsDangerousPatterns(code)) {
      throw new Error('Code contains potentially dangerous patterns')
    }

    const sandbox = new VM({
      timeout, // Execution timeout
      sandbox: {
        // Safe global objects
        console: {
          log: (...args) => {
            // Limit output size
            const output = args.join(' ').substring(0, 1000)
            this.logOutput(output)
          }
        },
        Math,
        Date,
        // Add other safe globals as needed
      },
      eval: false, // Disable eval
      wasm: false, // Disable WebAssembly
    })

    try {
      // Execute code in sandbox
      const result = sandbox.run(code)

      // Validate result
      if (typeof result === 'function') {
        throw new Error('Code cannot return functions')
      }

      if (result && typeof result === 'object' && result.constructor !== Object) {
        throw new Error('Code cannot return complex objects')
      }

      return JSON.stringify({
        success: true,
        result: result,
        executionTime: sandbox.executionTime
      })

    } catch (error) {
      return JSON.stringify({
        success: false,
        error: error.message.substring(0, 200) // Limit error message length
      })
    }
  }

  private containsDangerousPatterns(code: string): boolean {
    const dangerousPatterns = [
      /\b(eval|Function|setTimeout|setInterval)\b/g,
      /\b(require|import|export)\b/g,
      /\b(process|global|window|document)\b/g,
      /\b(fs|path|os|child_process)\b/g,
      /\b(__dirname|__filename)\b/g,
      /\b(console\.(error|warn|info|debug|trace))\b/g, // Allow only console.log
    ]

    return dangerousPatterns.some(pattern => pattern.test(code))
  }

  private logOutput(output: string) {
    // Log execution output for monitoring
    console.log('SANDBOX_OUTPUT:', output)
  }
}

// File operation sandboxing
class SecureFileTool extends Tool {
  private allowedPaths: Set<string>
  private maxFileSize = 1024 * 1024 // 1MB

  constructor(allowedPaths: string[]) {
    super({
      name: 'file_operation',
      description: 'Perform secure file operations',
      schema: z.object({
        operation: z.enum(['read', 'write', 'delete']),
        path: z.string(),
        content: z.string().optional()
      }),
      handler: (args) => this.executeSecureFileOperation(args)
    })

    this.allowedPaths = new Set(allowedPaths)
  }

  private async executeSecureFileOperation({ operation, path, content }) {
    // Path traversal protection
    const normalizedPath = path.normalize()
    if (!this.allowedPaths.has(normalizedPath)) {
      throw new Error('Access denied: Path not in allowed list')
    }

    // Additional security checks
    if (normalizedPath.includes('..') || normalizedPath.includes('~')) {
      throw new Error('Access denied: Invalid path')
    }

    switch (operation) {
      case 'read':
        return await this.secureReadFile(normalizedPath)

      case 'write':
        if (!content || content.length > this.maxFileSize) {
          throw new Error('Content too large or empty')
        }
        return await this.secureWriteFile(normalizedPath, content)

      case 'delete':
        return await this.secureDeleteFile(normalizedPath)

      default:
        throw new Error('Unknown operation')
    }
  }

  private async secureReadFile(path: string): Promise<string> {
    try {
      const stats = await fs.promises.stat(path)
      if (stats.size > this.maxFileSize) {
        throw new Error('File too large')
      }

      const content = await fs.promises.readFile(path, 'utf8')

      // Log file access
      await this.logFileAccess('read', path, content.length)

      return content
    } catch (error) {
      throw new Error(`File read failed: ${error.message}`)
    }
  }

  private async secureWriteFile(path: string, content: string): Promise<string> {
    // Backup existing file
    if (await this.fileExists(path)) {
      await fs.promises.copyFile(path, `${path}.backup`)
    }

    await fs.promises.writeFile(path, content, { mode: 0o644 }) // Secure permissions

    await this.logFileAccess('write', path, content.length)

    return JSON.stringify({ success: true, bytesWritten: content.length })
  }

  private async secureDeleteFile(path: string): Promise<string> {
    await fs.promises.unlink(path)
    await this.logFileAccess('delete', path)
    return JSON.stringify({ success: true })
  }

  private async fileExists(path: string): Promise<boolean> {
    try {
      await fs.promises.access(path)
      return true
    } catch {
      return false
    }
  }

  private async logFileAccess(operation: string, path: string, size?: number) {
    console.log('FILE_ACCESS:', JSON.stringify({
      operation,
      path,
      size,
      timestamp: new Date().toISOString(),
      user: this.getCurrentUser()
    }))
  }

  private getCurrentUser(): string {
    return 'agent-user' // In practice, get from authentication context
  }
}