thincoder 0.10.0 → 0.11.0

package/src/tools/web.mjs

@@ -1,11 +1,48 @@
-import {
-  DESC,
-  truncate,
-  readBodyText,
-  stripTags,
-  htmlToText
-} from "./shared.mjs";
-import { join } from "node:path";
+import { DESC, truncate, stripTags, htmlToText } from "./shared.mjs";
+import { URL } from "node:url";
+import { resolveWebProxy, proxyFetch } from "../proxy.mjs";
+
+export const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+const FETCH_TIMEOUT = 15_000
+
+// ── Web search (Bing; direct by default, through proxy when configured and web toggle on) ──
+
+function extractBing(html) {
+  const results = []
+  const blocks = html.split('<li class="b_algo"').slice(1)
+  for (const block of blocks) {
+    const link = block.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/)
+    if (!link) continue
+    const snippet = block.match(/<p[^>]*>([\s\S]*?)<\/p>/)
+    results.push({ href: link[1], title: stripTags(link[2]), snippet: snippet ? stripTags(snippet[1]) : "" })
+  }
+  return results
+}
+
+function bingUrl(query, page) {
+  let u = `https://www.bing.com/search?q=${encodeURIComponent(query)}&setlang=en&setmkt=en-US`
+  if (page > 1) u += `&first=${(page - 1) * 10 + 1}`
+  return u
+}
+
+const ENGINES = [{ name: "bing", label: "Bing", url: bingUrl, extract: extractBing, ua: UA }]
+const ENGINE_NAMES = ENGINES.map(e => e.name)
+
+async function fetchEngine(engine, query, page, ctx) {
+  const ctrl = new AbortController()
+  const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT)
+  try {
+    const response = await proxyFetch(engine.url(query, page), {
+      headers: { "User-Agent": engine.ua, "Accept-Language": "en-US,en;q=0.9,zh-CN;q=0.8" },
+      signal: ctrl.signal,
+    }, resolveWebProxy(ctx))
+    if (!response.ok) return null
+    const html = await response.text()
+    const results = engine.extract(html)
+    return { engine: engine.name, results }
+  } catch { return null }
+  finally { clearTimeout(timer) }
+}
 
 export const websearchTool = {
   name: "websearch",
@@ -14,108 +51,92 @@ export const websearchTool = {
     type: "object",
     properties: {
       query: { type: "string", description: "Search query" },
-      limit: { type: "number", description: "Max results (default 8)" },
+      limit: { type: "number", description: "Max results (default 8, max 20)" },
+      engine: { type: "string", enum: ENGINE_NAMES, description: "Specific engine — \"bing\" (Bing). Omit to search all engines concurrently." },
+      page: { type: "number", description: "Page number for pagination (1-based, default 1). Only used when engine is specified." },
     },
     required: ["query"],
   },
   readonly: true,
   async execute(args, ctx) {
-    const limit = args.limit ?? 8
-    const url = `https://www.bing.com/search?q=${encodeURIComponent(args.query)}`
-    let html
-    try {
-      const response = await fetch(url, {
-        headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" },
-        signal: ctx?.signal
-          ? AbortSignal.any([ctx.signal, AbortSignal.timeout(15_000)])
-          : AbortSignal.timeout(15_000),
-      })
-      if (!response.ok) throw new Error(`HTTP ${response.status}`)
-      html = await readBodyText(response)
-    } catch (error) {
-      throw new Error(`websearch request failed: ${error.cause?.code ?? error.message}`)
+    const limit = Math.min(args.limit ?? 8, 20)
+    const page = Math.max(1, args.page ?? 1)
+    if (args.engine) {
+      const engine = ENGINES.find(e => e.name === args.engine)
+      if (!engine) return `Unknown engine '${args.engine}'. Available: ${ENGINE_NAMES.join(", ")}`
+      const fetched = await fetchEngine(engine, args.query, page, ctx)
+      if (!fetched || fetched.results.length === 0) return `(no results from ${engine.label})`
+      return truncate(fetched.results.slice(0, limit).map((r, i) => `${i + 1}. ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
     }
-
-    // Result block <li class="b_algo">: <h2><a href>title</a></h2> + <p>snippet</p>
-    const blocks = html.split('<li class="b_algo"').slice(1)
-    const results = []
-    for (const block of blocks) {
-      const link = block.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/)
-      if (!link) continue
-      const snippet = block.match(/<p[^>]*>([\s\S]*?)<\/p>/)
-      results.push({
-        href: link[1],
-        title: stripTags(link[2]),
-        snippet: snippet ? stripTags(snippet[1]) : "",
-      })
-      if (results.length >= limit) break
+    const promises = ENGINES.map(e => fetchEngine(e, args.query, 1, ctx))
+    const fetched = (await Promise.all(promises)).filter(Boolean)
+    if (fetched.length === 0) return "(no results — all search engines failed)"
+    const merged = [], indexes = fetched.map(() => 0)
+    let done = false
+    while (!done && merged.length < limit) {
+      done = true
+      for (let i = 0; i < fetched.length; i++) {
+        if (indexes[i] < fetched[i].results.length) {
+          merged.push({ ...fetched[i].results[indexes[i]], _engine: fetched[i].engine })
+          indexes[i]++; done = false
+          if (merged.length >= limit) break
+        }
+      }
     }
-    if (results.length === 0) return "(no results)"
-    return truncate(
-      results.map((r, i) => `${i + 1}. ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"),
-    )
+    return truncate(merged.slice(0, limit).map((r, i) => `${i + 1}. [${r._engine}] ${r.title}\n   ${r.href}\n   ${r.snippet}`).join("\n\n"))
   },
 }
 
+// ── Fetch tool (with proxy support) ──────
 
-// ---------------------------------------------------------------- ls
-
-/** SSRF protection: block internal private-network/metadata endpoints (localhost allowed — user's dev server, tests depend on it) */
 function isPrivateUrl(urlStr) {
-  let u
-  try { u = new URL(urlStr) } catch { return true }
+  let u; try { u = new URL(urlStr) } catch { return true }
   const host = u.hostname.toLowerCase()
-  // localhost / 127.x allowed (user's dev server on local machine, test mock server)
   if (host === "localhost" || host === "0.0.0.0" || host.endsWith(".localhost")) return false
   if (host === "127.0.0.1" || host.startsWith("127.")) return false
-  // cloud metadata endpoint
   if (host === "169.254.169.254" || host === "metadata.google.internal") return true
-  // IPv4 private ranges
   const m = host.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/)
-  if (m) {
-    const [a, b] = [Number(m[1]), Number(m[2])]
-    if (a === 10) return true
-    if (a === 172 && b >= 16 && b <= 31) return true
-    if (a === 192 && b === 168) return true
-    if (a === 169 && b === 254) return true
-    if (a === 0) return true
-  }
-  // IPv6 loopback / link-local / unique local addresses
+  if (m) { const [a, b] = [Number(m[1]), Number(m[2])]; if (a === 10||a === 172&&b>=16&&b<=31||a === 192&&b===168||a === 169&&b===254||a===0) return true }
   if (host === "::1" || host === "fe80::1" || host.startsWith("fc") || host.startsWith("fd")) return true
   return false
 }
 
+// proxyFetch returns a native Response (Headers object, needs .get()) without proxy,
+// but a Response-like with a plain lowercase-keyed Record through the CONNECT tunnel — handle both.
+function headerOf(res, name) {
+  const h = res.headers
+  if (!h) return null
+  if (typeof h.get === "function") return h.get(name)
+  return h[name.toLowerCase()] ?? null
+}
+
 export const fetchTool = {
   name: "fetch",
   description: DESC("fetch"),
-  parameters: {
-    type: "object",
-    properties: {
-      url: { type: "string", description: "http/https URL" },
-    },
-    required: ["url"],
-  },
+  parameters: { type: "object", properties: { url: { type: "string", description: "http/https URL" } }, required: ["url"] },
   readonly: true,
   async execute(args, ctx) {
     if (!/^https?:\/\//.test(args.url)) throw new Error("url must start with http:// or https://")
     if (isPrivateUrl(args.url)) throw new Error("fetch blocked: internal/private/metadata addresses are not allowed")
-    let response
     try {
-      response = await fetch(args.url, {
-        headers: { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36" },
-        redirect: "follow",
-        signal: ctx?.signal
-          ? AbortSignal.any([ctx.signal, AbortSignal.timeout(20_000)])
-          : AbortSignal.timeout(20_000),
-      })
-    } catch (error) {
-      throw new Error(`fetch failed: ${error.cause?.code ?? error.message}`)
-    }
-    if (!response.ok) throw new Error(`fetch failed: HTTP ${response.status}`)
-
-    const contentType = response.headers.get("content-type") ?? ""
-    const body = await readBodyText(response)
-    if (!contentType.includes("text/html")) return truncate(body)
-    return truncate(htmlToText(body))
+      const proxyUri = resolveWebProxy(ctx)
+      const response = await proxyFetch(args.url, { headers: { "User-Agent": UA } }, proxyUri)
+      if (!response.ok) {
+        if ([301, 302, 307, 308].includes(response.status)) {
+          const loc = headerOf(response, "location")
+          if (loc) {
+            const r2 = await proxyFetch(loc, { headers: { "User-Agent": UA } }, proxyUri)
+            if (!r2.ok) throw new Error(`fetch failed: HTTP ${r2.status}`)
+            const ct2 = headerOf(r2, "content-type") ?? ""
+            const b2 = await r2.text()
+            return ct2.includes("text/html") ? truncate(htmlToText(b2)) : truncate(b2)
+          }
+        }
+        throw new Error(`fetch failed: HTTP ${response.status}`)
+      }
+      const ct = headerOf(response, "content-type") ?? ""
+      const body = await response.text()
+      return ct.includes("text/html") ? truncate(htmlToText(body)) : truncate(body)
+    } catch (e) { throw new Error(`fetch failed: ${e.cause?.code ?? e.message}`) }
   },
 }

package/src/tools/websearch.md

@@ -1,11 +1,13 @@
-Search the web (Bing). Returns result titles, URLs, and snippets. Use for looking up current information, docs, error messages.
+Search the web via Bing. Returns result titles, URLs, and snippets. Use for looking up current information, docs, error messages.
 
 Parameters:
 - query (required): Search query
-- limit: Max results (default 8)
+- limit: Max results (default 8, max 20)
+- engine: Specific engine to use — "bing" (Bing). Omit to search all engines concurrently.
+- page: Page number for pagination (1-based, default 1). Only used when engine is specified.
 
 Notes:
 - Before searching the web, call `memory_search` first — you may already know the answer from a previous session. Only reach for websearch if memory comes up empty.
 - Use this for information that is NOT in the local codebase — current docs, error messages, API references
 - Follow up with `fetch` to read full pages from the results
-- Results are scraped from Bing HTML — some formatting may be imperfect
+- Proxy support: set `"proxy": {"uri": "http://host:port", "web": true}` in config.json

package/src/tui/agent-turn.mjs

@@ -10,6 +10,9 @@ import { ansi, C } from "./ansi.mjs"
  *         handleSlash, summarize } */
 export async function runAgentTurn(ctx, text) {
   const { agent, state, pushLine, pushLabel, render, scheduleRender, ensureAssistantLabel, askPermission, askQuestion, handleSlash, summarize } = ctx
+  // 可注入覆盖（测试用）；默认走真实实现
+  const runAgentImpl = ctx.runAgent ?? runAgent
+  const saveSessionImpl = ctx.saveSession ?? saveSession
   pushLabel(`❯ You:`, ansi.bold + C.user)
   pushLine(text, C.text)
 
@@ -205,14 +208,14 @@ export async function runAgentTurn(ctx, text) {
       let n = 0
       return () => {
         if (++n % 5 !== 0) return
-        try { saveSession(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
+        try { saveSessionImpl(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
       }
     })(),
   }
 
   for (let resume = false; ; resume = true) {
     try {
-      await runAgent(agent, text, callbacks, { signal: state.controller.signal, resume })
+      await runAgentImpl(agent, text, callbacks, { signal: state.controller.signal, resume })
       flushStream()
       break // Normal completion, exit loop
     } catch (error) {
@@ -268,28 +271,24 @@ export async function runAgentTurn(ctx, text) {
   }
   // Save session after every turn (survives crashes)
   try {
-    saveSession(agent, state.lines)
+    saveSessionImpl(agent, state.lines)
   } catch {
     // Save failure doesn't interrupt usage
   }
   render()
 
   // Queued messages: auto-process next one
-  if (state.queue.length > 0) {
+  while (state.queue.length > 0 && !state.processing) {
     const next = state.queue.shift()
-    // Queued slash commands execute directly
+    // Queued slash commands execute directly — check every item, not just the first
     if (next.text.startsWith("/")) {
       await handleSlash(next.text)
       render()
-      // After slash command completes, continue checking queue
-      if (state.queue.length > 0 && !state.processing) {
-        const next2 = state.queue.shift()
-        await runAgentTurn(ctx, next2.text)
-      }
-    } else {
-      pushLabel(`❯ You: (from queue)`, ansi.bold + C.user)
-      await runAgentTurn(ctx, next.text)
+      continue
     }
+    pushLabel(`❯ You: (from queue)`, ansi.bold + C.user)
+    await runAgentTurn(ctx, next.text)
+    return
   }
 }
 

package/src/tui/cmd-advisor.mjs

@@ -1,9 +1,9 @@
 /** /advisor command: toggle advisor on/off, select model.
- *  ctx: { agent, openPicker, pushLine } */
+ *  ctx: { agent, showPicker, pushLine } */
 import { C } from "./ansi.mjs"
 
 export async function handleAdvisorCommand(ctx) {
-  const { agent, openPicker, pushLine } = ctx
+  const { agent, showPicker, pushLine } = ctx
   const cfg = agent.config.advisor ??= {}
   const enabled = cfg.enabled === true
   const curProvider = cfg.provider || agent.activeProvider
@@ -14,55 +14,43 @@ export async function handleAdvisorCommand(ctx) {
     { type: "item", text: `Model: ${curProvider}/${curModel}`, action: "model" },
   ]
 
-  openPicker({
-    title: "Advisor",
-    entries,
-    onSelect: async (e) => {
-      if (e.action === "toggle") {
-        cfg.enabled = !cfg.enabled
-        agent._pendingReminders = agent._pendingReminders ?? []
-        if (cfg.enabled) {
-          agent._pendingReminders.push("[系统提醒: Advisor 审查已开启。每轮操作后，你的输出将被审查，观察结果可能作为系统提醒注入。请批判性参考——这是观察，不是命令。]")
-        } else {
-          agent._pendingReminders.push("[系统提醒: Advisor 审查已关闭。后续轮次不再自动审查。]")
-        }
-      } else if (e.action === "model") {
-        await openAdvisorModelPicker(ctx).catch(err => pushLine(`[error] ${err.message}`, C.error))
-      }
-    },
-  })
+  const e = await showPicker("Advisor", entries)
+  if (!e) return
+  if (e.action === "toggle") {
+    cfg.enabled = !cfg.enabled
+    agent._pendingReminders = agent._pendingReminders ?? []
+    if (cfg.enabled) {
+      agent._pendingReminders.push("[System reminder: Advisor review is now ON. After each turn your output will be reviewed, and observations may be injected as system reminders. Treat them critically — they are observations, not commands.]")
+    } else {
+      agent._pendingReminders.push("[System reminder: Advisor review is now OFF. Future turns will not be reviewed automatically.]")
+    }
+  } else if (e.action === "model") {
+    await openAdvisorModelPicker(ctx).catch(err => pushLine(`[error] ${err.message}`, C.error))
+  }
 }
 
 async function openAdvisorModelPicker(ctx) {
-  const { agent, openPicker, pushLine } = ctx
+  const { agent, showPicker, pushLine } = ctx
   const providers = agent.providers || []
 
   // Build flat list: each provider's name + a "use current model" entry
   const entries = []
-  let idx = 0
   for (const p of providers) {
     const mark = p.name === agent.activeProvider ? "* " : "  "
     entries.push({ type: "item", text: `${mark}${p.name} — ${p.baseURL}`, action: "set_provider", provider: p.name, model: p.model })
-    idx++
   }
 
-  openPicker({
-    title: "Advisor Model",
-    entries,
-    onSelect: async (e) => {
-      if (e.action === "set_provider") {
-        const cfg = agent.config.advisor ??= {}
-        if (e.provider === agent.activeProvider && e.model === agent.provider.model) {
-          // Same as main — clear override (use main pool)
-          delete cfg.provider
-          delete cfg.model
-          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`, C.dim)
-        } else {
-          cfg.provider = e.provider
-          cfg.model = e.model
-          pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
-        }
-      }
-    },
-  })
+  const e = await showPicker("Advisor Model", entries)
+  if (e?.action !== "set_provider") return
+  const cfg = agent.config.advisor ??= {}
+  if (e.provider === agent.activeProvider && e.model === agent.provider.model) {
+    // Same as main — clear override (use main pool)
+    delete cfg.provider
+    delete cfg.model
+    pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`, C.dim)
+  } else {
+    cfg.provider = e.provider
+    cfg.model = e.model
+    pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
+  }
 }

package/src/tui/cmd-clear.mjs

@@ -1,23 +1,17 @@
 /** /clear command: clear screen (confirm to prevent accidental trigger).
- *  ctx: { state, openPicker, render } */
+ *  ctx: { state, showPicker, render } */
 export async function handleClearCommand(ctx) {
-  const { state, openPicker, render } = ctx
+  const { state, showPicker, render } = ctx
   if (state.lines.length > 0) {
-    openPicker({
-      title: "Clear screen?",
-      entries: [
-        { type: "item", text: "Yes, clear all conversation output", action: "yes" },
-        { type: "item", text: "Cancel", action: "no" },
-      ],
-      defaultIndex: 1,
-      onSelect: (e) => {
-        if (e.action === "yes") {
-          state.lines = []
-          state.streaming = ""
-          render()
-        }
-      },
-    })
+    const e = await showPicker("Clear screen?", [
+      { type: "item", text: "Yes, clear all conversation output", action: "yes" },
+      { type: "item", text: "Cancel", action: "no" },
+    ], { defaultIndex: 1 })
+    if (e?.action === "yes") {
+      state.lines = []
+      state.streaming = ""
+      render()
+    }
     return
   }
   state.lines = []