@shareai-lab/kode 1.0.80 → 1.0.82

package/src/tools/URLFetcherTool/cache.ts

@@ -0,0 +1,55 @@
+interface CacheEntry {
+  content: string
+  timestamp: number
+}
+
+class URLCache {
+  private cache = new Map<string, CacheEntry>()
+  private readonly CACHE_DURATION = 15 * 60 * 1000 // 15 minutes in milliseconds
+
+  set(url: string, content: string): void {
+    this.cache.set(url, {
+      content,
+      timestamp: Date.now()
+    })
+  }
+
+  get(url: string): string | null {
+    const entry = this.cache.get(url)
+    if (!entry) {
+      return null
+    }
+
+    // Check if entry has expired
+    if (Date.now() - entry.timestamp > this.CACHE_DURATION) {
+      this.cache.delete(url)
+      return null
+    }
+
+    return entry.content
+  }
+
+  clear(): void {
+    this.cache.clear()
+  }
+
+  // Clean expired entries
+  private cleanExpired(): void {
+    const now = Date.now()
+    for (const [url, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > this.CACHE_DURATION) {
+        this.cache.delete(url)
+      }
+    }
+  }
+
+  // Auto-clean expired entries every 5 minutes
+  constructor() {
+    setInterval(() => {
+      this.cleanExpired()
+    }, 5 * 60 * 1000) // 5 minutes
+  }
+}
+
+// Export singleton instance
+export const urlCache = new URLCache()

package/src/tools/URLFetcherTool/htmlToMarkdown.ts

@@ -0,0 +1,55 @@
+import TurndownService from 'turndown'
+
+const turndownService = new TurndownService({
+  headingStyle: 'atx',
+  hr: '---',
+  bulletListMarker: '-',
+  codeBlockStyle: 'fenced',
+  fence: '```',
+  emDelimiter: '_',
+  strongDelimiter: '**'
+})
+
+// Configure rules to handle common HTML elements
+turndownService.addRule('removeScripts', {
+  filter: ['script', 'style', 'noscript'],
+  replacement: () => ''
+})
+
+turndownService.addRule('removeComments', {
+  filter: (node) => node.nodeType === 8, // Comment nodes
+  replacement: () => ''
+})
+
+turndownService.addRule('cleanLinks', {
+  filter: 'a',
+  replacement: (content, node) => {
+    const href = node.getAttribute('href')
+    if (!href || href.startsWith('javascript:') || href.startsWith('#')) {
+      return content
+    }
+    return `[${content}](${href})`
+  }
+})
+
+export function convertHtmlToMarkdown(html: string): string {
+  try {
+    // Clean up the HTML before conversion
+    const cleanHtml = html
+      .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '') // Remove script tags
+      .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '') // Remove style tags
+      .replace(/<!--[\s\S]*?-->/g, '') // Remove HTML comments
+      .replace(/\s+/g, ' ') // Normalize whitespace
+      .trim()
+
+    const markdown = turndownService.turndown(cleanHtml)
+    
+    // Clean up the resulting markdown
+    return markdown
+      .replace(/\n{3,}/g, '\n\n') // Remove excessive line breaks
+      .replace(/^\s+|\s+$/gm, '') // Remove leading/trailing spaces on each line
+      .trim()
+  } catch (error) {
+    throw new Error(`Failed to convert HTML to markdown: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/URLFetcherTool/prompt.ts

@@ -0,0 +1,17 @@
+export const TOOL_NAME_FOR_PROMPT = 'URLFetcher'
+export const DESCRIPTION = `- Fetches content from a specified URL and processes it using an AI model
+- Takes a URL and a prompt as input
+- Fetches the URL content, converts HTML to markdown
+- Processes the content with the prompt using a small, fast model
+- Returns the model's response about the content
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+- IMPORTANT: If an MCP-provided web fetch tool is available, prefer using that tool instead of this one, as it may have fewer restrictions. All MCP-provided tools start with "mcp__".
+- The URL must be a fully-formed valid URL (e.g., https://example.com)
+- HTTP URLs will be automatically upgraded to HTTPS
+- The prompt should describe what information you want to extract from the page
+- This tool is read-only and does not modify any files
+- Results may be summarized if the content is very large
+- Includes a self-cleaning 15-minute cache for faster responses when repeatedly accessing the same URL
+- When a URL redirects, the tool will inform you and provide the redirect URL in a special format. You should then make a new URLFetcher request with the redirect URL to fetch the content.`

package/src/tools/WebSearchTool/WebSearchTool.tsx

@@ -0,0 +1,103 @@
+import { Box, Text } from 'ink'
+import React from 'react'
+import { z } from 'zod'
+import { Cost } from '../../components/Cost'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { Tool, ToolUseContext } from '../../Tool'
+import { DESCRIPTION, TOOL_NAME_FOR_PROMPT } from './prompt'
+import { SearchResult, searchProviders } from './searchProviders'
+
+const inputSchema = z.strictObject({
+  query: z.string().describe('The search query'),
+})
+
+type Input = z.infer<typeof inputSchema>
+type Output = {
+  durationMs: number
+  results: SearchResult[]
+}
+
+
+export const WebSearchTool = {
+  name: TOOL_NAME_FOR_PROMPT,
+  async description() {
+    return DESCRIPTION
+  },
+  userFacingName: () => 'Web Search',
+  inputSchema,
+  isReadOnly: () => true,
+  isConcurrencySafe: () => true,
+  async isEnabled() {
+    return true
+  },
+  needsPermissions() {
+    return false
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderToolUseMessage({ query }: Input) {
+    return `Searching for: "${query}" using DuckDuckGo`
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+  renderToolResultMessage(output: Output) {
+    return (
+      <Box justifyContent="space-between" width="100%">
+        <Box flexDirection="row">
+          <Text>&nbsp;&nbsp;⎿ &nbsp;Found </Text>
+          <Text bold>{output.results.length} </Text>
+          <Text>
+            {output.results.length === 1 ? 'result' : 'results'} using DuckDuckGo
+          </Text>
+        </Box>
+        <Cost costUSD={0} durationMs={output.durationMs} debug={false} />
+      </Box>
+    )
+  },
+  renderResultForAssistant(output: Output) {
+    if (output.results.length === 0) {
+      return `No results found using DuckDuckGo.`
+    }
+    
+    let result = `Found ${output.results.length} search results using DuckDuckGo:\n\n`
+    
+    output.results.forEach((item, index) => {
+      result += `${index + 1}. **${item.title}**\n`
+      result += `   ${item.snippet}\n`
+      result += `   Link: ${item.link}\n\n`
+    })
+    
+    result += `You can reference these results to provide current, accurate information to the user.`
+    return result
+  },
+  async *call({ query }: Input, {}: ToolUseContext) {
+    const start = Date.now()
+
+    try {
+      const searchResults = await searchProviders.duckduckgo.search(query)
+      
+      const output: Output = {
+        results: searchResults,
+        durationMs: Date.now() - start,
+      }
+
+      yield {
+        type: 'result' as const,
+        resultForAssistant: this.renderResultForAssistant(output),
+        data: output,
+      }
+    } catch (error: any) {
+      const output: Output = {
+        results: [],
+        durationMs: Date.now() - start,
+      }
+      yield {
+        type: 'result' as const,
+        resultForAssistant: `An error occurred during web search with DuckDuckGo: ${error.message}`,
+        data: output,
+      }
+    }
+  },
+} satisfies Tool<typeof inputSchema, Output>

package/src/tools/WebSearchTool/prompt.ts

@@ -0,0 +1,13 @@
+
+export const TOOL_NAME_FOR_PROMPT = 'WebSearch'
+export const DESCRIPTION = `- Allows Kode to search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks
+- Use this tool for accessing information beyond the Kode's knowledge cutoff
+- Searches are performed automatically within a single API call using DuckDuckGo
+
+Usage notes:
+- Use when you need current information not in training data
+- Effective for recent news, current events, product updates, or real-time data
+- Search queries should be specific and well-targeted for best results
+- Results include both title and snippet content for context`

package/src/tools/WebSearchTool/searchProviders.ts

@@ -0,0 +1,66 @@
+import fetch from 'node-fetch'
+import { parse } from 'node-html-parser'
+
+export interface SearchResult {
+  title: string
+  snippet: string
+  link: string
+}
+
+export interface SearchProvider {
+  search: (query: string, apiKey?: string) => Promise<SearchResult[]>
+  isEnabled: (apiKey?: string) => boolean
+}
+
+
+const duckDuckGoSearchProvider: SearchProvider = {
+  isEnabled: () => true,
+  search: async (query: string): Promise<SearchResult[]> => {
+    const response = await fetch(`https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error(`DuckDuckGo search failed with status: ${response.status}`);
+    }
+
+    const html = await response.text();
+    const root = parse(html);
+    const results: SearchResult[] = [];
+
+    const resultNodes = root.querySelectorAll('.result.web-result');
+
+    for (const node of resultNodes) {
+        const titleNode = node.querySelector('.result__a');
+        const snippetNode = node.querySelector('.result__snippet');
+
+        if (titleNode && snippetNode) {
+            const title = titleNode.text;
+            const link = titleNode.getAttribute('href');
+            const snippet = snippetNode.text;
+
+            if (title && link && snippet) {
+                // Clean the link - DuckDuckGo doesn't use uddg parameter anymore
+                let cleanLink = link;
+                if (link.startsWith('https://duckduckgo.com/l/?uddg=')) {
+                    try {
+                        const url = new URL(link);
+                        cleanLink = url.searchParams.get('uddg') || link;
+                    } catch {
+                        cleanLink = link;
+                    }
+                }
+                results.push({ title: title.trim(), snippet: snippet.trim(), link: cleanLink });
+            }
+        }
+    }
+
+    return results;
+  },
+}
+
+export const searchProviders = {
+  duckduckgo: duckDuckGoSearchProvider,
+}

package/src/tools.ts

@@ -16,6 +16,8 @@ import { NotebookEditTool } from './tools/NotebookEditTool/NotebookEditTool'
 import { NotebookReadTool } from './tools/NotebookReadTool/NotebookReadTool'
 import { ThinkTool } from './tools/ThinkTool/ThinkTool'
 import { TodoWriteTool } from './tools/TodoWriteTool/TodoWriteTool'
+import { WebSearchTool } from './tools/WebSearchTool/WebSearchTool'
+import { URLFetcherTool } from './tools/URLFetcherTool/URLFetcherTool'
 import { getMCPTools } from './services/mcpClient'
 import { memoize } from 'lodash-es'
 
@@ -38,6 +40,8 @@ export const getAllTools = (): Tool[] => {
     NotebookEditTool as unknown as Tool,
     ThinkTool as unknown as Tool,
     TodoWriteTool as unknown as Tool,
+    WebSearchTool as unknown as Tool,
+    URLFetcherTool as unknown as Tool,
     ...ANT_ONLY_TOOLS,
   ]
 }

package/src/utils/PersistentShell.ts

@@ -37,6 +37,165 @@ const SHELL_CONFIGS: Record<string, string> = {
   '/bin/zsh': '.zshrc',
 }
 
+type DetectedShell = {
+  bin: string
+  args: string[]
+  type: 'posix' | 'msys' | 'wsl'
+}
+
+function quoteForBash(str: string): string {
+  return `'${str.replace(/'/g, "'\\''")}'`
+}
+
+function toBashPath(pathStr: string, type: 'posix' | 'msys' | 'wsl'): string {
+  // Already POSIX absolute path
+  if (pathStr.startsWith('/')) return pathStr
+  if (type === 'posix') return pathStr
+
+  // Normalize backslashes
+  const normalized = pathStr.replace(/\\/g, '/').replace(/\\\\/g, '/')
+  const driveMatch = /^[A-Za-z]:/.exec(normalized)
+  if (driveMatch) {
+    const drive = normalized[0].toLowerCase()
+    const rest = normalized.slice(2)
+    if (type === 'msys') {
+      return `/` + drive + (rest.startsWith('/') ? rest : `/${rest}`)
+    }
+    // wsl
+    return `/mnt/` + drive + (rest.startsWith('/') ? rest : `/${rest}`)
+  }
+  // Relative path: just convert slashes
+  return normalized
+}
+
+function fileExists(p: string | undefined): p is string {
+  return !!p && existsSync(p)
+}
+
+// Robust PATH splitter for Windows and POSIX
+function splitPathEntries(pathEnv: string, platform: NodeJS.Platform): string[] {
+  if (!pathEnv) return []
+
+  // POSIX: ':' is the separator
+  if (platform !== 'win32') {
+    return pathEnv
+      .split(':')
+      .map(s => s.trim().replace(/^"|"$/g, ''))
+      .filter(Boolean)
+  }
+
+  // Windows: primarily ';', but some environments may use ':'
+  // We must not split drive letters like 'C:\\' or 'D:foo\\bar'
+  const entries: string[] = []
+  let current = ''
+  const pushCurrent = () => {
+    const cleaned = current.trim().replace(/^"|"$/g, '')
+    if (cleaned) entries.push(cleaned)
+    current = ''
+  }
+
+  for (let i = 0; i < pathEnv.length; i++) {
+    const ch = pathEnv[i]
+
+    if (ch === ';') {
+      pushCurrent()
+      continue
+    }
+
+    if (ch === ':') {
+      const segmentLength = current.length
+      const firstChar = current[0]
+      const isDriveLetterPrefix = segmentLength === 1 && /[A-Za-z]/.test(firstChar || '')
+      // Treat ':' as separator only if it's NOT the drive letter colon
+      if (!isDriveLetterPrefix) {
+        pushCurrent()
+        continue
+      }
+    }
+
+    current += ch
+  }
+
+  // Flush the final segment
+  pushCurrent()
+
+  return entries
+}
+
+function detectShell(): DetectedShell {
+  const isWin = process.platform === 'win32'
+  if (!isWin) {
+    const bin = process.env.SHELL || '/bin/bash'
+    return { bin, args: ['-l'], type: 'posix' }
+  }
+
+  // 1) Respect SHELL if it points to a bash.exe that exists
+  if (process.env.SHELL && /bash\.exe$/i.test(process.env.SHELL) && existsSync(process.env.SHELL)) {
+    return { bin: process.env.SHELL, args: ['-l'], type: 'msys' }
+  }
+
+  // 1.1) Explicit override
+  if (process.env.KODE_BASH && existsSync(process.env.KODE_BASH)) {
+    return { bin: process.env.KODE_BASH, args: ['-l'], type: 'msys' }
+  }
+
+  // 2) Common Git Bash/MSYS2 locations
+  const programFiles = [
+    process.env['ProgramFiles'],
+    process.env['ProgramFiles(x86)'],
+    process.env['ProgramW6432'],
+  ].filter(Boolean) as string[]
+
+  const localAppData = process.env['LocalAppData']
+
+  const candidates: string[] = []
+  for (const base of programFiles) {
+    candidates.push(
+      join(base, 'Git', 'bin', 'bash.exe'),
+      join(base, 'Git', 'usr', 'bin', 'bash.exe'),
+    )
+  }
+  if (localAppData) {
+    candidates.push(
+      join(localAppData, 'Programs', 'Git', 'bin', 'bash.exe'),
+      join(localAppData, 'Programs', 'Git', 'usr', 'bin', 'bash.exe'),
+    )
+  }
+  // MSYS2 default
+  candidates.push('C:/msys64/usr/bin/bash.exe')
+
+  for (const c of candidates) {
+    if (existsSync(c)) {
+      return { bin: c, args: ['-l'], type: 'msys' }
+    }
+  }
+
+  // 2.1) Search in PATH for bash.exe
+  const pathEnv = process.env.PATH || process.env.Path || process.env.path || ''
+  const pathEntries = splitPathEntries(pathEnv, process.platform)
+  for (const p of pathEntries) {
+    const candidate = join(p, 'bash.exe')
+    if (existsSync(candidate)) {
+      return { bin: candidate, args: ['-l'], type: 'msys' }
+    }
+  }
+
+  // 3) WSL
+  try {
+    // Quick probe to ensure WSL+bash exists
+    execSync('wsl.exe -e bash -lc "echo KODE_OK"', { stdio: 'ignore', timeout: 1500 })
+    return { bin: 'wsl.exe', args: ['-e', 'bash', '-l'], type: 'wsl' }
+  } catch {}
+
+  // 4) Last resort: meaningful error
+  const hint = [
+    '无法找到可用的 bash。请安装 Git for Windows 或启用 WSL。',
+    '推荐安装 Git: https://git-scm.com/download/win',
+    '或启用 WSL 并安装 Ubuntu: https://learn.microsoft.com/windows/wsl/install',
+  ].join('\n')
+  throw new Error(hint)
+}
+
 export class PersistentShell {
   private commandQueue: QueuedCommand[] = []
   private isExecuting: boolean = false
@@ -49,10 +208,20 @@ export class PersistentShell {
   private cwdFile: string
   private cwd: string
   private binShell: string
+  private shellArgs: string[]
+  private shellType: 'posix' | 'msys' | 'wsl'
+  private statusFileBashPath: string
+  private stdoutFileBashPath: string
+  private stderrFileBashPath: string
+  private cwdFileBashPath: string
 
   constructor(cwd: string) {
-    this.binShell = process.env.SHELL || '/bin/bash'
-    this.shell = spawn(this.binShell, ['-l'], {
+    const { bin, args, type } = detectShell()
+    this.binShell = bin
+    this.shellArgs = args
+    this.shellType = type
+
+    this.shell = spawn(this.binShell, this.shellArgs, {
       stdio: ['pipe', 'pipe', 'pipe'],
       cwd,
       env: {
@@ -98,13 +267,15 @@ export class PersistentShell {
     }
     // Initialize CWD file with initial directory
     fs.writeFileSync(this.cwdFile, cwd)
-    const configFile = SHELL_CONFIGS[this.binShell]
-    if (configFile) {
-      const configFilePath = join(homedir(), configFile)
-      if (existsSync(configFilePath)) {
-        this.sendToShell(`source ${configFilePath}`)
-      }
-    }
+
+    // Compute bash-visible paths for redirections
+    this.statusFileBashPath = toBashPath(this.statusFile, this.shellType)
+    this.stdoutFileBashPath = toBashPath(this.stdoutFile, this.shellType)
+    this.stderrFileBashPath = toBashPath(this.stderrFile, this.shellType)
+    this.cwdFileBashPath = toBashPath(this.cwdFile, this.shellType)
+
+    // Source ~/.bashrc when available (works for bash on POSIX/MSYS/WSL)
+    this.sendToShell('[ -f ~/.bashrc ] && source ~/.bashrc || true')
   }
 
   private static instance: PersistentShell | null = null
@@ -232,10 +403,17 @@ export class PersistentShell {
 
     // Check the syntax of the command
     try {
-      execSync(`${this.binShell} -n -c ${quotedCommand}`, {
-        stdio: 'ignore',
-        timeout: 1000,
-      })
+      if (this.shellType === 'wsl') {
+        execSync(`wsl.exe -e bash -n -c ${quotedCommand}`, {
+          stdio: 'ignore',
+          timeout: 1000,
+        })
+      } else {
+        execSync(`${this.binShell} -n -c ${quotedCommand}`, {
+          stdio: 'ignore',
+          timeout: 1000,
+        })
+      }
     } catch (stderr) {
       // If there's a syntax error, return an error and log it
       const errorStr =
@@ -264,17 +442,17 @@ export class PersistentShell {
 
       // 1. Execute the main command with redirections
       commandParts.push(
-        `eval ${quotedCommand} < /dev/null > ${this.stdoutFile} 2> ${this.stderrFile}`,
+        `eval ${quotedCommand} < /dev/null > ${quoteForBash(this.stdoutFileBashPath)} 2> ${quoteForBash(this.stderrFileBashPath)}`,
       )
 
       // 2. Capture exit code immediately after command execution to avoid losing it
       commandParts.push(`EXEC_EXIT_CODE=$?`)
 
       // 3. Update CWD file
-      commandParts.push(`pwd > ${this.cwdFile}`)
+      commandParts.push(`pwd > ${quoteForBash(this.cwdFileBashPath)}`)
 
       // 4. Write the preserved exit code to status file to avoid race with pwd
-      commandParts.push(`echo $EXEC_EXIT_CODE > ${this.statusFile}`)
+      commandParts.push(`echo $EXEC_EXIT_CODE > ${quoteForBash(this.statusFileBashPath)}`)
 
       // Send the combined commands as a single operation to maintain atomicity
       this.sendToShell(commandParts.join('\n'))
@@ -363,7 +541,8 @@ export class PersistentShell {
     if (!existsSync(resolved)) {
       throw new Error(`Path "${resolved}" does not exist`)
     }
-    await this.exec(`cd ${resolved}`)
+    const bashPath = toBashPath(resolved, this.shellType)
+    await this.exec(`cd ${quoteForBash(bashPath)}`)
   }
 
   close(): void {

package/src/utils/debugLogger.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, appendFileSync } from 'fs'
 import { join } from 'path'
+import { homedir } from 'os'
 import { randomUUID } from 'crypto'
 import chalk from 'chalk'
 import envPaths from 'env-paths'
@@ -60,14 +61,14 @@ const USER_FRIENDLY_LEVELS = new Set([
 const STARTUP_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, '-')
 const REQUEST_START_TIME = Date.now()
 
-// 路径配置
-const paths = envPaths(PRODUCT_COMMAND)
+// 路径配置 - 统一使用 ~/.kode 目录
+const KODE_DIR = join(homedir(), '.kode')
 function getProjectDir(cwd: string): string {
   return cwd.replace(/[^a-zA-Z0-9]/g, '-')
 }
 
 const DEBUG_PATHS = {
-  base: () => join(paths.cache, getProjectDir(process.cwd()), 'debug'),
+  base: () => join(KODE_DIR, getProjectDir(process.cwd()), 'debug'),
   detailed: () => join(DEBUG_PATHS.base(), `${STARTUP_TIMESTAMP}-detailed.log`),
   flow: () => join(DEBUG_PATHS.base(), `${STARTUP_TIMESTAMP}-flow.log`),
   api: () => join(DEBUG_PATHS.base(), `${STARTUP_TIMESTAMP}-api.log`),
@@ -467,11 +468,16 @@ export function logAPIError(context: {
   response?: any
   provider?: string
 }) {
-  const errorDir = join(paths.cache, getProjectDir(process.cwd()), 'logs', 'error', 'api')
+  const errorDir = join(KODE_DIR, 'logs', 'error', 'api')
   
   // 确保目录存在
   if (!existsSync(errorDir)) {
-    mkdirSync(errorDir, { recursive: true })
+    try {
+      mkdirSync(errorDir, { recursive: true })
+    } catch (err) {
+      console.error('Failed to create error log directory:', err)
+      return // Exit early if we can't create the directory
+    }
   }
   
   // 生成文件名
@@ -557,7 +563,7 @@ export function logAPIError(context: {
     }
     
     console.log()
-    console.log(chalk.dim(`  📁 Full log: ~/.kode/logs/error/api/${filename}`))
+    console.log(chalk.dim(`  📁 Full log: ${filepath}`))
     console.log(chalk.red('━'.repeat(60)))
     console.log()
   }