@raolin2025/claude-code-node 1.0.0

package/src/tools/file-read.js

@@ -0,0 +1,105 @@
+/**
+ * FileRead 工具 — 读取文件
+ * 对应原版: src/tools/FileReadTool/
+ */
+import { readFile, stat } from 'fs/promises'
+import { resolve, isAbsolute } from 'path'
+import { ToolDef } from '../types/index.js'
+import { checkPathSafety } from '../security/path-guard.js'
+
+const MAX_LINES = 2000
+const MAX_SIZE_BYTES = 256 * 1024 // 256KB
+
+export const fileReadTool = new ToolDef(
+  'Read',
+  `Read a file from the local filesystem.
+Usage:
+- The file_path must be an absolute path
+- Optionally specify offset (1-based line number) and limit
+- Results use cat -n format with line numbers
+- Supports text files, images (PNG/JPG/GIF/WebP), and PDFs`,
+  {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'The absolute path to the file to read',
+      },
+      offset: {
+        type: 'number',
+        description: 'Line number to start reading from (1-based)',
+      },
+      limit: {
+        type: 'number',
+        description: 'Maximum number of lines to read',
+      },
+    },
+    required: ['file_path'],
+  },
+  async (input, ctx) => {
+    let filePath = input.file_path
+    if (!isAbsolute(filePath)) {
+      filePath = resolve(ctx.cwd || process.cwd(), filePath)
+    }
+
+    // 路径安全检查
+    const pathResult = checkPathSafety(filePath, { cwd: ctx.cwd || process.cwd() })
+    if (!pathResult.safe) {
+      return `[🚫 路径被安全策略阻止]\n${pathResult.reasons.join('\n')}`
+    }
+
+    try {
+      const fileStat = await stat(filePath)
+
+      // 检查文件大小
+      if (fileStat.size > MAX_SIZE_BYTES && !input.offset && !input.limit) {
+        return `[File too large: ${fileStat.size} bytes > ${MAX_SIZE_BYTES} limit. Use offset/limit to read portions.]`
+      }
+
+      // 图片文件检测
+      const ext = filePath.split('.').pop().toLowerCase()
+      const imageExts = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp']
+      if (imageExts.includes(ext)) {
+        const buf = await readFile(filePath)
+        const base64 = buf.toString('base64')
+        const mime = ext === 'svg' ? 'image/svg+xml' : `image/${ext === 'jpg' ? 'jpeg' : ext}`
+        return `[Image: ${filePath} (${(fileStat.size / 1024).toFixed(1)}KB)] data:${mime};base64,${base64.slice(0, 100)}...`
+      }
+
+      // 文本文件
+      const content = await readFile(filePath, 'utf-8')
+      const lines = content.split('\n')
+
+      const offset = input.offset ? Math.max(1, input.offset) - 1 : 0
+      const limit = input.limit || MAX_LINES
+      const sliced = lines.slice(offset, offset + limit)
+
+      // cat -n 格式
+      const numbered = sliced
+        .map((line, i) => {
+          const lineNum = String(offset + i + 1).padStart(6, ' ')
+          return `${lineNum}\t${line}`
+        })
+        .join('\n')
+
+      const totalLines = lines.length
+      const readLines = sliced.length
+      let result = numbered
+
+      if (offset > 0 || readLines < totalLines) {
+        result += `\n\n[${readLines} of ${totalLines} lines shown (lines ${offset + 1}-${offset + readLines})]`
+      }
+
+      return result
+    } catch (err) {
+      if (err.code === 'ENOENT') {
+        return `[File not found: ${filePath}]`
+      }
+      if (err.code === 'EISDIR') {
+        return `[Path is a directory, not a file: ${filePath}. Use Bash with ls to list directory contents.]`
+      }
+      return `[Error reading file: ${err.message}]`
+    }
+  },
+  'always-allow'
+)

package/src/tools/file-write.js

@@ -0,0 +1,57 @@
+/**
+ * FileWrite 工具 — 写入/创建文件
+ * 对应原版: src/tools/FileWriteTool/
+ */
+import { writeFile, mkdir } from 'fs/promises'
+import { resolve, isAbsolute, dirname } from 'path'
+import { ToolDef } from '../types/index.js'
+import { checkWritePathSafety } from '../security/path-guard.js'
+
+export const fileWriteTool = new ToolDef(
+  'Write',
+  `Write content to a file. Creates the file if it doesn't exist, overwrites if it does.
+Usage:
+- file_path must be an absolute path
+- content is the text to write
+- Parent directories are created automatically
+- This tool will OVERWRITE existing files - use Edit for partial changes`,
+  {
+    type: 'object',
+    properties: {
+      file_path: {
+        type: 'string',
+        description: 'The absolute path to the file to write',
+      },
+      content: {
+        type: 'string',
+        description: 'The content to write to the file',
+      },
+    },
+    required: ['file_path', 'content'],
+  },
+  async (input, ctx) => {
+    let filePath = input.file_path
+    if (!isAbsolute(filePath)) {
+      filePath = resolve(ctx.cwd || process.cwd(), filePath)
+    }
+
+    // 写入路径安全检查
+    const pathResult = checkWritePathSafety(filePath, { cwd: ctx.cwd || process.cwd() })
+    if (!pathResult.safe) {
+      return `[🚫 路径被安全策略阻止]\n${pathResult.reasons.join('\n')}`
+    }
+
+    try {
+      // 自动创建父目录
+      await mkdir(dirname(filePath), { recursive: true })
+      await writeFile(filePath, input.content, 'utf-8')
+
+      const lines = input.content.split('\n').length
+      const size = Buffer.byteLength(input.content, 'utf-8')
+      return `Successfully wrote to ${filePath} (${lines} lines, ${size} bytes)`
+    } catch (err) {
+      return `[Error writing file: ${err.message}]`
+    }
+  },
+  'ask'
+)

package/src/tools/glob.js

@@ -0,0 +1,113 @@
+/**
+ * Glob 工具 — 文件模式搜索
+ * 对应原版: src/tools/GlobTool/
+ */
+import { readdir, stat } from 'fs/promises'
+import { resolve, join, isAbsolute } from 'path'
+import { ToolDef } from '../types/index.js'
+
+/**
+ * 简单的 glob 模式匹配器
+ * 支持 * (任意非/字符) 和 ** (任意路径)
+ */
+function globToRegex(pattern) {
+  let regex = ''
+  let i = 0
+  while (i < pattern.length) {
+    const ch = pattern[i]
+    if (ch === '*' && pattern[i + 1] === '*') {
+      if (pattern[i + 2] === '/') {
+        regex += '(?:.*/)?'
+        i += 3
+      } else {
+        regex += '.*'
+        i += 2
+      }
+    } else if (ch === '*') {
+      regex += '[^/]*'
+      i++
+    } else if (ch === '?') {
+      regex += '[^/]'
+      i++
+    } else if ('.+^${}()|[]\\'.includes(ch)) {
+      regex += '\\' + ch
+      i++
+    } else {
+      regex += ch
+      i++
+    }
+  }
+  return new RegExp('^' + regex + '$')
+}
+
+async function* walkDir(dir, ignoreDirs = []) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        // 跳过常见的忽略目录
+        if (ignoreDirs.includes(entry.name)) continue
+        if (entry.name.startsWith('.') && entry.name !== '.claude') continue
+        yield* walkDir(fullPath, ignoreDirs)
+      } else if (entry.isFile()) {
+        yield fullPath
+      }
+    }
+  } catch {
+    // 忽略权限错误等
+  }
+}
+
+export const globTool = new ToolDef(
+  'Glob',
+  `Find files matching a glob pattern.
+Usage:
+- pattern supports * (any non-path chars) and ** (any path segment)
+- path is the base directory to search from (default: cwd)
+- Results are returned as a list of file paths`,
+  {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description: 'The glob pattern to match (e.g. "**/*.js", "src/**/*.ts")',
+      },
+      path: {
+        type: 'string',
+        description: 'The base directory to search from (default: cwd)',
+      },
+    },
+    required: ['pattern'],
+  },
+  async (input, ctx) => {
+    const baseDir = input.path
+      ? (isAbsolute(input.path) ? input.path : resolve(ctx.cwd || process.cwd(), input.path))
+      : (ctx.cwd || process.cwd())
+
+    const pattern = input.pattern
+    const regex = globToRegex(pattern)
+    const ignoreDirs = ['node_modules', '.git', '__pycache__', '.svn', 'dist', 'build', '.next']
+
+    const matches = []
+    const MAX_RESULTS = 200
+
+    for await (const filePath of walkDir(baseDir, ignoreDirs)) {
+      const relativePath = filePath.slice(baseDir.length + 1)
+      if (regex.test(relativePath) || regex.test(filePath)) {
+        matches.push(filePath)
+        if (matches.length >= MAX_RESULTS) {
+          matches.push(`... (truncated at ${MAX_RESULTS} results)`)
+          break
+        }
+      }
+    }
+
+    if (matches.length === 0) {
+      return `[No files matching pattern: ${pattern} in ${baseDir}]`
+    }
+
+    return matches.join('\n')
+  },
+  'always-allow'
+)

package/src/tools/grep.js

@@ -0,0 +1,117 @@
+/**
+ * Grep 工具 — 内容搜索
+ * 对应原版: src/tools/GrepTool/
+ * 优先使用 ripgrep (rg)，回退到 grep，最后用纯 JS 实现
+ */
+import { spawn } from 'child_process'
+import { resolve, isAbsolute } from 'path'
+import { ToolDef } from '../types/index.js'
+
+async function grepWithRg(pattern, path, options = {}) {
+  const args = ['--line-number', '--color=never']
+  if (options.ignore_case) args.push('-i')
+  if (options.file_pattern) args.push('--glob', options.file_pattern)
+  if (options.context_lines) args.push('-C', String(options.context_lines))
+  args.push(pattern, path)
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('rg', args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    proc.stdout.on('data', d => stdout += d)
+    proc.stderr.on('data', d => stderr += d)
+    proc.on('close', (code) => {
+      // rg exit 1 = no matches, 2 = error
+      if (code === 0 || code === 1) resolve(stdout)
+      else resolve(`[ripgrep error: ${stderr}]`)
+    })
+    proc.on('error', () => resolve(null)) // rg not found
+    proc.stdin.end()
+  })
+}
+
+async function grepWithGrep(pattern, path, options = {}) {
+  const args = ['-rn', '--color=never']
+  if (options.ignore_case) args.push('-i')
+  if (options.file_pattern) args.push('--include', options.file_pattern)
+  if (options.context_lines) args.push('-C', String(options.context_lines))
+  args.push(pattern, path)
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn('grep', args, { stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    proc.stdout.on('data', d => stdout += d)
+    proc.stderr.on('data', d => stderr += d)
+    proc.on('close', (code) => {
+      if (code === 0 || code === 1) resolve(stdout)
+      else resolve(`[grep error: ${stderr}]`)
+    })
+    proc.on('error', () => resolve(null))
+    proc.stdin.end()
+  })
+}
+
+export const grepTool = new ToolDef(
+  'Grep',
+  `Search file contents with a regex pattern.
+Usage:
+- pattern is a regular expression (RE2 syntax for rg, BRE/ERE for grep)
+- path is the directory to search in (default: cwd)
+- Use ignore_case for case-insensitive search
+- Use file_pattern to filter by filename (e.g. "*.js")
+- Results show file:line:content format`,
+  {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description: 'The regular expression pattern to search for',
+      },
+      path: {
+        type: 'string',
+        description: 'The directory to search in (default: cwd)',
+      },
+      ignore_case: {
+        type: 'boolean',
+        description: 'Case-insensitive search (default: false)',
+      },
+      file_pattern: {
+        type: 'string',
+        description: 'File name pattern filter (e.g. "*.js", "*.{ts,tsx}")',
+      },
+      context_lines: {
+        type: 'number',
+        description: 'Number of context lines before/after match',
+      },
+    },
+    required: ['pattern'],
+  },
+  async (input, ctx) => {
+    const searchPath = input.path
+      ? (isAbsolute(input.path) ? input.path : resolve(ctx.cwd || process.cwd(), input.path))
+      : (ctx.cwd || process.cwd())
+
+    // 尝试 rg → grep → 纯 JS
+    let result = await grepWithRg(input.pattern, searchPath, input)
+    if (result === null) {
+      result = await grepWithGrep(input.pattern, searchPath, input)
+    }
+    if (result === null) {
+      result = `[Neither ripgrep nor grep found. Install rg for best performance.]`
+    }
+
+    // 截断过长输出
+    const MAX_OUTPUT = 50000
+    if (result.length > MAX_OUTPUT) {
+      result = result.slice(0, MAX_OUTPUT) + `\n\n[... truncated at ${MAX_OUTPUT} chars]`
+    }
+
+    if (!result.trim()) {
+      return `[No matches for pattern: ${input.pattern} in ${searchPath}]`
+    }
+
+    return result
+  },
+  'always-allow'
+)

package/src/tools/index.js

@@ -0,0 +1,110 @@
+/**
+ * 工具注册表 — 导出所有内置工具
+ */
+import { bashTool } from './bash.js'
+import { fileReadTool } from './file-read.js'
+import { fileEditTool } from './file-edit.js'
+import { fileWriteTool } from './file-write.js'
+import { globTool } from './glob.js'
+import { grepTool } from './grep.js'
+import { webFetchTool } from './web-fetch.js'
+import { webSearchTool } from './web-search.js'
+import { askUserTool } from './ask-user.js'
+
+/**
+ * 所有内置工具列表
+ */
+export const builtinTools = [
+  bashTool,
+  fileReadTool,
+  fileEditTool,
+  fileWriteTool,
+  globTool,
+  grepTool,
+  webFetchTool,
+  webSearchTool,
+  askUserTool,
+]
+
+/**
+ * 工具注册表 — 管理所有可用工具
+ */
+export class ToolRegistry {
+  constructor() {
+    this.tools = new Map()
+  }
+
+  /** 注册一个工具 */
+  register(tool) {
+    this.tools.set(tool.name, tool)
+    return this
+  }
+
+  /** 批量注册 */
+  registerAll(tools) {
+    for (const tool of tools) {
+      this.register(tool)
+    }
+    return this
+  }
+
+  /** 获取工具 */
+  get(name) {
+    return this.tools.get(name)
+  }
+
+  /** 获取所有工具 */
+  getAll() {
+    return Array.from(this.tools.values())
+  }
+
+  /** 获取工具名称列表 */
+  getNames() {
+    return Array.from(this.tools.keys())
+  }
+
+  /** 注销工具 */
+  unregister(name) {
+    return this.tools.delete(name)
+  }
+
+  /** 检查工具是否存在 */
+  has(name) {
+    return this.tools.has(name)
+  }
+
+  /** 生成 OpenAI function-calling 格式的工具定义 */
+  toOpenAITools() {
+    return this.getAll().map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+      },
+    }))
+  }
+
+  /** 生成 tool_use 格式的工具定义（兼容多种 API） */
+  getToolDefinitions() {
+    return this.getAll().map(t => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters,
+    }))
+  }
+
+  /** @deprecated 使用 getToolDefinitions() 替代 */
+  toAnthropicTools() {
+    return this.getToolDefinitions()
+  }
+}
+
+/**
+ * 创建包含所有内置工具的注册表
+ */
+export function createDefaultRegistry() {
+  const registry = new ToolRegistry()
+  registry.registerAll(builtinTools)
+  return registry
+}

package/src/tools/web-fetch.js

@@ -0,0 +1,125 @@
+/**
+ * WebFetch 工具 — 抓取网页内容
+ * 对应原版: src/tools/WebFetchTool/
+ */
+import { ToolDef } from '../types/index.js'
+import { checkUrlSafety } from '../security/ssrf-guard.js'
+
+const MAX_FETCH_CHARS = 100000
+
+/**
+ * 简单的 HTML → 纯文本转换
+ */
+function htmlToText(html) {
+  let text = html
+  // 移除 script/style
+  text = text.replace(/<script[\s\S]*?<\/script>/gi, '')
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, '')
+  text = text.replace(/<nav[\s\S]*?<\/nav>/gi, '')
+  // 保留一些有用的标签语义
+  text = text.replace(/<h[1-6][^>]*>/gi, '\n## ')
+  text = text.replace(/<\/h[1-6]>/gi, '\n')
+  text = text.replace(/<p[^>]*>/gi, '\n')
+  text = text.replace(/<br\s*\/?>/gi, '\n')
+  text = text.replace(/<li[^>]*>/gi, '\n- ')
+  text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)')
+  text = text.replace(/<img[^>]*alt="([^"]*)"[^>]*>/gi, '[image: $1]')
+  // 移除所有剩余 HTML 标签
+  text = text.replace(/<[^>]+>/g, '')
+  // 解码常见 HTML 实体
+  text = text.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+  text = text.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, ' ')
+  // 清理多余空白
+  text = text.replace(/\n{3,}/g, '\n\n').trim()
+
+  return text
+}
+
+export const webFetchTool = new ToolDef(
+  'WebFetch',
+  `Fetch and extract content from a URL.
+Usage:
+- url must be a valid HTTP/HTTPS URL
+- Returns the page content as cleaned text/markdown
+- Supports HTML pages, plain text, and JSON APIs`,
+  {
+    type: 'object',
+    properties: {
+      url: {
+        type: 'string',
+        description: 'The URL to fetch',
+      },
+      format: {
+        type: 'string',
+        enum: ['text', 'json', 'raw'],
+        description: 'Output format: text (cleaned HTML), json (parse as JSON), raw (raw response)',
+      },
+    },
+    required: ['url'],
+  },
+  async (input, ctx) => {
+    const { url, format = 'text' } = input
+
+    // SSRF 安全检查
+    const urlSafety = await checkUrlSafety(url)
+    if (!urlSafety.allowed) {
+      return `[🚫 URL 被安全策略阻止]\n${urlSafety.reason}`
+    }
+
+    try {
+      const response = await fetch(url, {
+        headers: {
+          'User-Agent': 'ClaudeCode-Node/1.0',
+          'Accept': 'text/html,application/json,text/plain,*/*',
+        },
+        signal: AbortSignal.timeout(30000),
+      })
+
+      if (!response.ok) {
+        return `[HTTP ${response.status} ${response.statusText}]`
+      }
+
+      const contentType = response.headers.get('content-type') || ''
+      const body = await response.text()
+
+      // JSON 格式
+      if (format === 'json' || contentType.includes('application/json')) {
+        try {
+          const data = JSON.parse(body)
+          const formatted = JSON.stringify(data, null, 2)
+          return formatted.length > MAX_FETCH_CHARS
+            ? formatted.slice(0, MAX_FETCH_CHARS) + '\n[...truncated]'
+            : formatted
+        } catch {
+          return body.slice(0, MAX_FETCH_CHARS)
+        }
+      }
+
+      // 原始格式
+      if (format === 'raw') {
+        return body.length > MAX_FETCH_CHARS
+          ? body.slice(0, MAX_FETCH_CHARS) + '\n[...truncated]'
+          : body
+      }
+
+      // HTML → 文本
+      if (contentType.includes('text/html')) {
+        const text = htmlToText(body)
+        return text.length > MAX_FETCH_CHARS
+          ? text.slice(0, MAX_FETCH_CHARS) + '\n[...truncated]'
+          : text
+      }
+
+      // 纯文本
+      return body.length > MAX_FETCH_CHARS
+        ? body.slice(0, MAX_FETCH_CHARS) + '\n[...truncated]'
+        : body
+    } catch (err) {
+      if (err.name === 'TimeoutError') {
+        return `[Error: Request timed out after 30s]`
+      }
+      return `[Error fetching URL: ${err.message}]`
+    }
+  },
+  'ask'
+)

package/src/tools/web-search.js

@@ -0,0 +1,75 @@
+/**
+ * WebSearch 工具 — 网页搜索（占位符）
+ * 对应原版: src/tools/WebSearchTool/
+ */
+import { ToolDef } from '../types/index.js'
+
+export const webSearchTool = new ToolDef(
+  'WebSearch',
+  `Search the web for information.
+NOTE: This tool requires a search API key to be configured.
+Set BRAVE_SEARCH_API_KEY or GOOGLE_SEARCH_API_KEY in environment variables.`,
+  {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'The search query',
+      },
+      count: {
+        type: 'number',
+        description: 'Number of results to return (default: 10)',
+      },
+    },
+    required: ['query'],
+  },
+  async (input, ctx) => {
+    const braveKey = process.env.BRAVE_SEARCH_API_KEY
+    const googleKey = process.env.GOOGLE_SEARCH_API_KEY
+    const googleCx = process.env.GOOGLE_SEARCH_CX
+
+    // 尝试 Brave Search
+    if (braveKey) {
+      try {
+        const url = `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(input.query)}&count=${input.count || 10}`
+        const response = await fetch(url, {
+          headers: { 'X-Subscription-Token': braveKey, 'Accept': 'application/json' },
+          signal: AbortSignal.timeout(15000),
+        })
+        if (response.ok) {
+          const data = await response.json()
+          const results = (data.web?.results || []).map((r, i) =>
+            `${i + 1}. [${r.title}](${r.url})\n   ${r.description || ''}`
+          ).join('\n\n')
+          return results || `[No results found for: ${input.query}]`
+        }
+      } catch (err) {
+        return `[Brave Search error: ${err.message}]`
+      }
+    }
+
+    // 尝试 Google Custom Search
+    if (googleKey && googleCx) {
+      try {
+        const url = `https://www.googleapis.com/customsearch/v1?key=${googleKey}&cx=${googleCx}&q=${encodeURIComponent(input.query)}&num=${input.count || 10}`
+        const response = await fetch(url, { signal: AbortSignal.timeout(15000) })
+        if (response.ok) {
+          const data = await response.json()
+          const results = (data.items || []).map((r, i) =>
+            `${i + 1}. [${r.title}](${r.link})\n   ${r.snippet || ''}`
+          ).join('\n\n')
+          return results || `[No results found for: ${input.query}]`
+        }
+      } catch (err) {
+        return `[Google Search error: ${err.message}]`
+      }
+    }
+
+    return `[WebSearch requires an API key. Set one of:
+- BRAVE_SEARCH_API_KEY (Brave Search API)
+- GOOGLE_SEARCH_API_KEY + GOOGLE_SEARCH_CX (Google Custom Search)
+
+Query was: "${input.query}"]`
+  },
+  'ask'
+)