export interface ToolDefinition<TArgs = any, TResult = any> {
  name: string
  description: string
  parameters: {
    type: 'object'
    properties: Record<string, any>
    required?: string[]
  }
  execute: (args: TArgs) => Promise<TResult>
}

import * as fs from 'fs/promises'
import { ToolDefinition } from './types'

export const readTool: ToolDefinition<{
  file_path: string
  offset?: number
  limit?: number
}> = {
  name: 'Read',
  description: '读取指定文件的文本内容。对大型文件必须指定 offset 和 limit 参数，只检索需要的行范围。',
  parameters: {
    type: 'object',
    properties: {
      file_path: { type: 'string', description: '待读取文件的绝对路径或相对工作区路径' },
      offset: { type: 'integer', description: '起始行号（从 1 开始，可选）' },
      limit: { type: 'integer', description: '读取的最大行数（可选）' }
    },
    required: ['file_path']
  },
  execute: async ({ file_path, offset = 1, limit = 200 }) => {
    const raw = await fs.readFile(file_path, 'utf-8')
    const lines = raw.split('\n')
    const startIdx = Math.max(0, offset - 1)
    const endIdx = limit ? startIdx + limit : lines.length

    const sliced = lines.slice(startIdx, endIdx)
    return sliced.map((line, idx) => `${startIdx + idx + 1}\t${line}`).join('\n')
  }
}

export async function executeToolCalls(
  toolCalls: ToolCall[],
  toolsMap: Map<string, ToolDefinition>,
  sequential = false
): Promise<ToolResult[]> {
  const executeSingle = async (call: ToolCall): Promise<ToolResult> => {
    const tool = toolsMap.get(call.name)
    if (!tool) {
      return {
        toolCallId: call.id,
        content: `Error: Tool '${call.name}' not found.`,
        isError: true
      }
    }
    try {
      const output = await tool.execute(call.arguments)
      return {
        toolCallId: call.id,
        content: typeof output === 'string' ? output : JSON.stringify(output)
      }
    } catch (err: any) {
      return {
        toolCallId: call.id,
        content: `Execution error: ${err.message}`,
        isError: true
      }
    }
  }

  if (sequential) {
    // 强制顺序执行模式
    const results: ToolResult[] = []
    for (const call of toolCalls) {
      results.push(await executeSingle(call))
    }
    return results
  }

  // 默认：并行执行
  return Promise.all(toolCalls.map(executeSingle))
}

import { spawn, ChildProcess } from 'child_process'
import * as readline from 'readline'

export class McpProcessBridge {
  private child: ChildProcess
  private requestId = 0
  private pending = new Map<number, { resolve: (val: any) => void; reject: (err: any) => void }>()

  constructor(command: string, args: string[]) {
    this.child = spawn(command, args, { stdio: ['pipe', 'pipe', 'inherit'] })

    const rl = readline.createInterface({ input: this.child.stdout! })
    rl.on('line', (line) => {
      try {
        const json = JSON.parse(line)
        if (json.id && this.pending.has(json.id)) {
          const { resolve, reject } = this.pending.get(json.id)!
          this.pending.delete(json.id)
          if (json.error) reject(new Error(json.error.message))
          else resolve(json.result)
        }
      } catch (e) {
        // 忽略非 JSON 行
      }
    })
  }

  async sendRequest<T = any>(method: string, params: Record<string, any> = {}): Promise<T> {
    const id = ++this.requestId
    const message = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n'

    return new Promise((resolve, reject) => {
      this.pending.set(id, { resolve, reject })
      this.child.stdin!.write(message)
    })
  }

  async listTools() {
    return this.sendRequest('tools/list')
  }

  async callTool(name: string, args: Record<string, any>) {
    return this.sendRequest('tools/call', { name, arguments: args })
  }
}

const FORBIDDEN_PATTERNS = [
  /rm\s+-rf\s+\//,
  /sudo\s+/,
  /curl.*\|\s*sh/,
  /chmod\s+777/
]

import * as dns from 'dns/promises'

export async function isPrivateAddress(hostname: string): Promise<boolean> {
  const { address } = await dns.lookup(hostname)
  return /^(10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[0-1])\.|127\.)/.test(address)
}