devin-search-mcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# Devin Search MCP
+
+[![npm version](https://img.shields.io/npm/v/devin-search-mcp.svg)](https://www.npmjs.com/package/devin-search-mcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+基于 Devin 原生引擎的 AI 联网网页搜索与深度抓取 MCP (Model Context Protocol) 插件。
+
+项目整体设计与工程规范深度对齐 `@sammysnake/fast-context-mcp`，支持跨平台本地凭证自动提取、健壮的模型输出修复、全网实时搜索与智能正文清洗。
+
+---
+
+## 特性亮点
+
+* **全网实时搜索 (`devin_web_search`)**：直接使用 Devin 官方针对开发者深度优化的搜索网关，获取最新的开源项目、技术文档、版本发布与报错解决方案。
+* **本地凭证自动提取 (`extract_devin_key`)**：深度模仿 `fast-context-mcp`，依赖 `sql.js`（纯 WASM/JS）自动扫描 `state.vscdb` 和 `credentials.toml`，一键导出有效凭据。
+* **深度网页正文抓取 (`devin_web_fetch`)**：自动剔除网页广告、导航、页脚等噪声，返回整洁的 Markdown 格式。
+* **响应自动修复与容错 (`response-repair`)**：内置括号深度平衡与畸形 JSON 自动修复算法，避免大模型输出解析崩溃。
+* **智能缓存加速 (`cache`)**：内置基于 MD5 与 TTL 的轻量缓存，相同搜索毫秒级返回，节约配额并加速响应。
+* **CI/CD 全自动发布**：配置了 GitHub Actions 自动化发布工作流，开箱即支持一键发包到 npm。
+
+---
+
+## 提供的 MCP 工具
+
+| 工具名称 | 功能描述 | 关键参数 |
+| :--- | :--- | :--- |
+| `devin_web_search` | 执行全网实时搜索，返回结构化网页列表及摘要 | `query` (必需), `num_results`, `detailed` |
+| `devin_web_fetch` | 抓取并阅读指定网址的深度清洁正文 | `url` (必需), `extract_mode` (`markdown`/`text`/`summary`) |
+| `extract_devin_key` | 跨平台自动提取本地 Devin / Windsurf API Key | 无 |
+| `devin_status` | 诊断检测本地 Devin 安装路径、登录身份与可用性状态 | 无 |
+
+---
+
+## 快速配置使用
+
+在任意 AI 客户端（如 CodeBuddy、Claude Desktop、Cursor 等）的 MCP 配置文件中添加：
+
+### 本地路径运行方式
+
+```json
+{
+  "mcpServers": {
+    "devin-search": {
+      "command": "node",
+      "args": [
+        "E:\\project\\devin-search-mcp\\bin\\devin-search-mcp.mjs"
+      ]
+    }
+  }
+}
+```
+
+### npm 发布后的运行方式 (与 fast-context-mcp 一致)
+
+```json
+{
+  "mcpServers": {
+    "devin-search": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "devin-search-mcp"
+      ]
+    }
+  }
+}
+```
+
+---
+
+## 验证与测试
+
+```bash
+cd E:\project\devin-search-mcp
+
+# 运行底层业务功能测试 (搜索与抓取)
+npm test
+
+# 运行真实的 MCP 客户端 Stdio 协议模拟测试
+npm run test:mcp
+```
+
+---
+
+## 如何发布到 npm
+
+1. **登录 npm**：
+   ```bash
+   npm login
+   ```
+2. **发布公有包**：
+   ```bash
+   npm publish --access public
+   ```
+3. **GitHub Actions 自动发布**：
+   在 GitHub 仓库中配置 Secret `NPM_TOKEN`，每次创建 Release Tag 时会自动触发打包发布。
+
+---
+
+## 许可证
+MIT License

package/bin/devin-search-mcp.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+/**
+ * devin-search-mcp 命令行入口
+ */
+
+import { runServer } from "../src/index.mjs";
+
+runServer().catch((error) => {
+  console.error("启动 devin-search-mcp 时发生严重错误:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "devin-search-mcp",
+  "version": "1.0.0",
+  "description": "Devin AI 驱动的联网搜索与网页抓取 MCP 服务 (基于 Devin Desktop / CLI)",
+  "main": "src/index.mjs",
+  "type": "module",
+  "bin": {
+    "devin-search-mcp": "./bin/devin-search-mcp.mjs"
+  },
+  "scripts": {
+    "start": "node ./bin/devin-search-mcp.mjs",
+    "test": "node test.mjs",
+    "test:mcp": "node test-mcp-protocol.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "devin",
+    "web-search",
+    "search",
+    "webfetch",
+    "ai",
+    "claude"
+  ],
+  "author": "suvon",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/soulvon/devin-search-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/soulvon/devin-search-mcp/issues"
+  },
+  "homepage": "https://github.com/soulvon/devin-search-mcp#readme",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "sql.js": "^1.14.2",
+    "zod": "^3.23.8"
+  }
+}

package/src/cache.mjs

@@ -0,0 +1,49 @@
+/**
+ * 轻量级搜索缓存模块
+ * 支持内存缓存与基于 TTL 的自动失效机制
+ */
+
+import { createHash } from "node:crypto";
+
+class SimpleCache {
+  constructor(defaultTtlMs = 30 * 60 * 1000) {
+    this.cache = new Map();
+    this.defaultTtlMs = defaultTtlMs;
+  }
+
+  generateKey(namespace, query, options = {}) {
+    const raw = `${namespace}:${query}:${JSON.stringify(options)}`;
+    return createHash("md5").update(raw).digest("hex");
+  }
+
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+
+    if (Date.now() > entry.expireAt) {
+      this.cache.delete(key);
+      return null;
+    }
+
+    return entry.value;
+  }
+
+  set(key, value, ttlMs = this.defaultTtlMs) {
+    // 限制最大缓存数量为 100 条
+    if (this.cache.size >= 100) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) this.cache.delete(firstKey);
+    }
+
+    this.cache.set(key, {
+      value,
+      expireAt: Date.now() + ttlMs,
+    });
+  }
+
+  clear() {
+    this.cache.clear();
+  }
+}
+
+export const searchCache = new SimpleCache();

package/src/detector.mjs

@@ -0,0 +1,158 @@
+/**
+ * Devin 运行环境与安装路径探测模块
+ * 支持自动探测 Windows / macOS / Linux 下的 devin.exe 和登录凭据
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import { execFileSync } from "node:child_process";
+
+/**
+ * 获取系统平台候选的 devin.exe / devin 路径
+ */
+export function getDevinPathCandidates() {
+  const plat = platform();
+  const home = homedir();
+  const candidates = [];
+
+  // 1. 优先使用环境变量指定
+  if (process.env.DEVIN_PATH) {
+    candidates.push(process.env.DEVIN_PATH);
+  }
+  if (process.env.DEVIN_EXE_PATH) {
+    candidates.push(process.env.DEVIN_EXE_PATH);
+  }
+
+  if (plat === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || join(home, "AppData", "Local");
+    const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+
+    candidates.push(
+      // 用户当前机器的主安装路径
+      "E:\\Program\\devin\\resources\\app\\extensions\\windsurf\\devin\\bin\\devin.exe",
+      "D:\\Program\\devin\\resources\\app\\extensions\\windsurf\\devin\\bin\\devin.exe",
+      "C:\\Program\\devin\\resources\\app\\extensions\\windsurf\\devin\\bin\\devin.exe",
+      // Windows 默认安装位置
+      join(localAppData, "Programs", "Devin", "resources", "app", "extensions", "windsurf", "devin", "bin", "devin.exe"),
+      join(programFiles, "Devin", "resources", "app", "extensions", "windsurf", "devin", "bin", "devin.exe"),
+      // 官方独立 CLI 安装路径
+      join(localAppData, "devin", "bin", "devin.exe"),
+      join(home, ".devin", "bin", "devin.exe")
+    );
+  } else if (plat === "darwin") {
+    candidates.push(
+      "/Applications/Devin.app/Contents/Resources/app/extensions/windsurf/devin/bin/devin",
+      join(home, "Applications", "Devin.app", "Contents", "Resources", "app", "extensions", "windsurf", "devin", "bin", "devin"),
+      join(home, ".local", "bin", "devin"),
+      "/usr/local/bin/devin"
+    );
+  } else {
+    // Linux
+    candidates.push(
+      join(home, ".local", "bin", "devin"),
+      join(home, ".devin", "bin", "devin"),
+      "/usr/local/bin/devin",
+      "/usr/bin/devin"
+    );
+  }
+
+  return candidates;
+}
+
+/**
+ * 自动查找有效的 devin 可执行文件路径
+ */
+export function findDevinExecutable() {
+  const candidates = getDevinPathCandidates();
+  for (const candidate of candidates) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  // 尝试直接通过系统 PATH 执行 devin
+  try {
+    const cmd = platform() === "win32" ? "where.exe devin" : "which devin";
+    const stdout = execFileSync(platform() === "win32" ? "cmd.exe" : "sh", [
+      platform() === "win32" ? "/c" : "-c",
+      cmd,
+    ], { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] }).trim();
+
+    const firstMatch = stdout.split(/\r?\n/)[0]?.trim();
+    if (firstMatch && existsSync(firstMatch)) {
+      return firstMatch;
+    }
+  } catch {
+    // PATH 中未找到
+  }
+
+  return null;
+}
+
+/**
+ * 获取凭证配置文件路径
+ */
+export function getCredentialsPath() {
+  const plat = platform();
+  const home = homedir();
+
+  let credPath = "";
+  if (plat === "win32") {
+    const appdata = process.env.APPDATA || join(home, "AppData", "Roaming");
+    credPath = join(appdata, "devin", "credentials.toml");
+  } else {
+    credPath = join(home, ".local", "share", "devin", "credentials.toml");
+  }
+
+  if (existsSync(credPath)) {
+    return credPath;
+  }
+  return null;
+}
+
+/**
+ * 读取 Devin 登录状态与信息
+ */
+export function inspectDevinStatus() {
+  const executable = findDevinExecutable();
+  const credentialsPath = getCredentialsPath();
+
+  let hasToken = false;
+  let tokenSnippet = null;
+
+  if (credentialsPath && existsSync(credentialsPath)) {
+    try {
+      const content = readFileSync(credentialsPath, "utf-8");
+      const match = content.match(/windsurf_api_key\s*=\s*"([^"]+)"/);
+      if (match && match[1]) {
+        hasToken = true;
+        tokenSnippet = match[1].slice(0, 25) + "...";
+      }
+    } catch {
+      // 忽略读取错误
+    }
+  }
+
+  let authStatusText = "";
+  if (executable) {
+    try {
+      authStatusText = execFileSync(executable, ["auth", "status"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 5000,
+      }).trim();
+    } catch (err) {
+      authStatusText = err.stdout || err.message;
+    }
+  }
+
+  return {
+    executable,
+    credentialsPath,
+    hasToken,
+    tokenSnippet,
+    isLoggedIn: authStatusText.includes("Logged in"),
+    statusSummary: authStatusText,
+  };
+}

package/src/extract-key.mjs

@@ -0,0 +1,175 @@
+/**
+ * Devin / Windsurf API Key 本地自动提取模块
+ * 模仿 fast-context-mcp 的跨平台本地凭证自动提取实现
+ * 依赖 sql.js (纯 WebAssembly/JS)，无需本地 C++ 编译环境
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir, platform } from "node:os";
+import initSqlJs from "sql.js";
+
+const TOML_API_KEY_FIELDS = [
+  "windsurf_api_key",
+  "devin_api_key",
+  "api_key",
+  "apiKey",
+  "access_token",
+  "token",
+];
+
+/**
+ * 获取平台相关的 state.vscdb 候选路径
+ */
+export function getDbPathCandidates() {
+  const plat = platform();
+  const home = homedir();
+  const env = process.env;
+
+  if (plat === "darwin") {
+    return ["Devin", "Windsurf"].map((appName) =>
+      join(home, "Library", "Application Support", appName, "User", "globalStorage", "state.vscdb")
+    );
+  }
+
+  if (plat === "win32") {
+    const appdata = env.APPDATA || join(home, "AppData", "Roaming");
+    return ["Devin", "Windsurf"].map((appName) =>
+      join(appdata, appName, "User", "globalStorage", "state.vscdb")
+    );
+  }
+
+  const config = env.XDG_CONFIG_HOME || join(home, ".config");
+  return ["Devin", "Windsurf"].map((appName) =>
+    join(config, appName, "User", "globalStorage", "state.vscdb")
+  );
+}
+
+/**
+ * 获取 credentials.toml 候选路径
+ */
+export function getTomlPathCandidates() {
+  const plat = platform();
+  const home = homedir();
+  const env = process.env;
+
+  if (plat === "win32") {
+    const appdata = env.APPDATA || join(home, "AppData", "Roaming");
+    return [
+      join(appdata, "devin", "credentials.toml"),
+      join(home, ".devin", "credentials.toml"),
+      join(home, ".codeium", "credentials.toml"),
+    ];
+  }
+
+  return [
+    join(home, ".local", "share", "devin", "credentials.toml"),
+    join(home, ".config", "devin", "credentials.toml"),
+    join(home, ".devin", "credentials.toml"),
+    join(home, ".codeium", "credentials.toml"),
+  ];
+}
+
+/**
+ * 从 TOML 文本中提取 key
+ */
+function extractFromTomlText(text) {
+  for (const field of TOML_API_KEY_FIELDS) {
+    const match = text.match(new RegExp(`^\\s*${field}\\s*=\\s*(?:"([^"]+)"|'([^']+)'|([^\\s#]+))`, "m"));
+    const val = (match?.[1] || match?.[2] || match?.[3] || "").trim();
+    if (val && val.length > 10) return val;
+  }
+  return null;
+}
+
+/**
+ * 从 SQLite state.vscdb 中提取 session token
+ */
+async function extractFromSqlite(dbPath) {
+  if (!existsSync(dbPath)) return null;
+
+  try {
+    const fileBuffer = readFileSync(dbPath);
+    const SQL = await initSqlJs();
+    const db = new SQL.Database(fileBuffer);
+
+    // 查询所有可能包含 token 的键值
+    const res = db.exec("SELECT key, value FROM ItemTable WHERE key LIKE '%devin%' OR key LIKE '%windsurf%' OR key LIKE '%codeium%' OR key LIKE '%token%' OR key LIKE '%auth%'");
+    if (!res || !res.length || !res[0].values) return null;
+
+    for (const row of res[0].values) {
+      const val = String(row[1] || "");
+      // 匹配常见 Token 格式
+      const tokenMatch = val.match(/devin-session-token\$[a-zA-Z0-9._-]+|sk-ws-[a-zA-Z0-9._-]+|eyJ[a-zA-Z0-9._-]+/);
+      if (tokenMatch) {
+        return tokenMatch[0];
+      }
+    }
+  } catch {
+    // 忽略解析错误
+  }
+  return null;
+}
+
+/**
+ * 跨平台自动提取 Devin API Key
+ */
+export async function extractDevinKey() {
+  // 1. 优先读取环境变量
+  if (process.env.DEVIN_API_KEY) {
+    return {
+      api_key: process.env.DEVIN_API_KEY,
+      source: "env:DEVIN_API_KEY",
+      app: "Devin",
+      length: process.env.DEVIN_API_KEY.length,
+    };
+  }
+  if (process.env.WINDSURF_API_KEY) {
+    return {
+      api_key: process.env.WINDSURF_API_KEY,
+      source: "env:WINDSURF_API_KEY",
+      app: "Windsurf",
+      length: process.env.WINDSURF_API_KEY.length,
+    };
+  }
+
+  // 2. 查找 credentials.toml
+  for (const tomlPath of getTomlPathCandidates()) {
+    if (existsSync(tomlPath)) {
+      try {
+        const text = readFileSync(tomlPath, "utf-8");
+        const key = extractFromTomlText(text);
+        if (key) {
+          return {
+            api_key: key,
+            source: tomlPath,
+            app: tomlPath.includes("devin") ? "Devin" : "Windsurf",
+            length: key.length,
+          };
+        }
+      } catch {}
+    }
+  }
+
+  // 3. 查找 state.vscdb
+  for (const dbPath of getDbPathCandidates()) {
+    if (existsSync(dbPath)) {
+      const key = await extractFromSqlite(dbPath);
+      if (key) {
+        return {
+          api_key: key,
+          source: dbPath,
+          app: dbPath.includes("Devin") ? "Devin" : "Windsurf",
+          length: key.length,
+        };
+      }
+    }
+  }
+
+  return {
+    api_key: null,
+    source: null,
+    app: null,
+    length: 0,
+  };
+}

package/src/fetch.mjs

@@ -0,0 +1,75 @@
+/**
+ * Devin 网页抓取与阅读模块
+ * 调用 Devin CLI 的 webfetch 工具提取指定网页的清洁正文
+ */
+
+import { execFile } from "node:child_process";
+import { findDevinExecutable } from "./detector.mjs";
+import { searchCache } from "./cache.mjs";
+
+/**
+ * 抓取指定 URL 的网页内容
+ * @param {Object} options
+ * @param {string} options.url - 目标网页 URL
+ * @param {"markdown"|"text"|"summary"} [options.extractMode="markdown"] - 提取格式
+ * @param {number} [options.timeoutMs=35000] - 超时毫秒数
+ */
+export async function executeWebFetch({ url, extractMode = "markdown", timeoutMs = 35000 }) {
+  if (!url || typeof url !== "string" || !/^https?:\/\//i.test(url)) {
+    throw new Error("请提供有效的 HTTP/HTTPS 网页 URL");
+  }
+
+  const cacheKey = searchCache.generateKey("web_fetch", url, { extractMode });
+  const cached = searchCache.get(cacheKey);
+  if (cached) {
+    return { ...cached, cached: true };
+  }
+
+  const devinExe = findDevinExecutable();
+  if (!devinExe) {
+    throw new Error("未找到 Devin 可执行文件，请确认已安装 Devin 或设置 DEVIN_PATH 环境变量。");
+  }
+
+  let prompt = "";
+  if (extractMode === "summary") {
+    prompt = `请使用 webfetch 工具读取 ${url} 的内容，并提供一份精准详实的核心内容提炼与关键要点总结。`;
+  } else if (extractMode === "text") {
+    prompt = `请使用 webfetch 工具读取 ${url} 的内容，去除网页导航、广告和页脚，直接输出主要正文纯文本。`;
+  } else {
+    prompt = `请使用 webfetch 工具读取 ${url} 的内容，并将正文内容转换为整洁、规范的 Markdown 格式输出。不要添加任何额外多余的寒暄。`;
+  }
+
+  const output = await new Promise((resolve, reject) => {
+    execFile(
+      devinExe,
+      ["--permission-mode", "dangerous", "--respect-workspace-trust", "false", "-p", prompt],
+      {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+        encoding: "utf-8",
+        env: { ...process.env, DEVIN_PERMISSION_MODE: "dangerous" },
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed) {
+            reject(new Error(`网页读取超时（超过 ${timeoutMs / 1000} 秒）: ${url}`));
+          } else {
+            reject(new Error(`网页读取失败: ${error.message}\n${stderr || ""}`));
+          }
+          return;
+        }
+        resolve(stdout.trim());
+      }
+    );
+  });
+
+  const resultPayload = {
+    url,
+    extractMode,
+    content: output,
+    cached: false,
+  };
+
+  searchCache.set(cacheKey, resultPayload);
+  return resultPayload;
+}

package/src/index.mjs

@@ -0,0 +1,226 @@
+/**
+ * Devin Search MCP Server
+ * 遵循 Model Context Protocol 标准实现 (对齐 fast-context-mcp 规范)
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+import { inspectDevinStatus } from "./detector.mjs";
+import { extractDevinKey } from "./extract-key.mjs";
+import { executeWebSearch } from "./search.mjs";
+import { executeWebFetch } from "./fetch.mjs";
+
+export function createDevinSearchServer() {
+  const server = new Server(
+    {
+      name: "devin-search-mcp",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "devin_web_search",
+          description:
+            "AI 驱动的实时网页搜索工具 (基于 Devin 联网引擎)。通过自然语言检索全网技术文档、最新版本特性、解决方案和开源生态，输出包含标题、URL及核心摘录的结构化结果。\n\n参数提示:\n- query: 搜索词或自然语言问题 (必填)\n- num_results: 返回条数 (默认 5)\n- detailed: 设置为 true 可额外附带深度技术见解与综合总结",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "自然语言搜索查询 (例如: 'Next.js 15 features', 'Vue 3.5 reactive props')",
+              },
+              num_results: {
+                type: "integer",
+                minimum: 1,
+                maximum: 15,
+                default: 5,
+                description: "期望返回的结果数量 (默认 5，建议 3-10)",
+              },
+              max_results: {
+                type: "integer",
+                description: "num_results 的兼容别名",
+              },
+              detailed: {
+                type: "boolean",
+                default: false,
+                description: "是否返回深度 AI 综合总结与结论分析",
+              },
+            },
+            required: ["query"],
+          },
+        },
+        {
+          name: "devin_web_fetch",
+          description:
+            "抓取并深度阅读指定网页的正文。自动过滤广告、导航、页脚与杂乱代码，支持输出纯正文或规范的 Markdown 格式。",
+          inputSchema: {
+            type: "object",
+            properties: {
+              url: {
+                type: "string",
+                description: "目标网页的完整 URL (必须以 http:// 或 https:// 开头)",
+              },
+              extract_mode: {
+                type: "string",
+                enum: ["markdown", "text", "summary"],
+                default: "markdown",
+                description: "正文提取格式: 'markdown' (结构化文档，默认), 'text' (纯文本), 'summary' (核心要点摘要)",
+              },
+            },
+            required: ["url"],
+          },
+        },
+        {
+          name: "extract_devin_key",
+          description:
+            "从本地安装中自动提取 Devin / Windsurf API Key (对齐 fast-context-mcp 的 extract_windsurf_key)。自动检测操作系统，读取 state.vscdb 或 credentials.toml 并输出有效凭据。",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
+        },
+        {
+          name: "devin_status",
+          description: "诊断工具: 检测本地 Devin 安装路径、登录身份与可用性状态。",
+          inputSchema: {
+            type: "object",
+            properties: {},
+          },
+        },
+      ],
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+      if (name === "devin_web_search") {
+        const query = args?.query;
+        const numResults = args?.num_results ?? args?.max_results ?? 5;
+        const detailed = args?.detailed ?? false;
+
+        const result = await executeWebSearch({
+          query,
+          num_results: numResults,
+          detailed,
+        });
+
+        const lines = [
+          `[config] ${result.config} (耗时: ${result.latencyMs}ms, 缓存命中: ${result.cached})`,
+          "",
+        ];
+
+        if (detailed && result.summary) {
+          lines.push(result.summary);
+        } else {
+          lines.push(JSON.stringify(result.results, null, 2));
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: lines.join("\n"),
+            },
+          ],
+        };
+      }
+
+      if (name === "devin_web_fetch") {
+        const url = args?.url;
+        const extractMode = args?.extract_mode ?? "markdown";
+
+        const result = await executeWebFetch({
+          url,
+          extractMode,
+        });
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.content,
+            },
+          ],
+        };
+      }
+
+      if (name === "extract_devin_key") {
+        const res = await extractDevinKey();
+        if (!res.api_key) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "未在本地找到有效的 Devin / Windsurf API Key。请确认 Devin Desktop 处于登录状态。",
+              },
+            ],
+          };
+        }
+
+        const text = [
+          "Devin API Key extracted successfully",
+          "",
+          `  Key: ${res.api_key.slice(0, 25)}...${res.api_key.slice(-15)}`,
+          `  Length: ${res.length}`,
+          `  Source: ${res.source}`,
+          `  App: ${res.app}`,
+          "",
+          "Usage:",
+          `  export DEVIN_API_KEY="${res.api_key}"`,
+        ].join("\n");
+
+        return {
+          content: [{ type: "text", text }],
+        };
+      }
+
+      if (name === "devin_status") {
+        const status = inspectDevinStatus();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(status, null, 2),
+            },
+          ],
+        };
+      }
+
+      throw new Error(`未知的工具名称: ${name}`);
+    } catch (error) {
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `[devin-search-mcp 出错] ${error.message}`,
+          },
+        ],
+      };
+    }
+  });
+
+  return server;
+}
+
+export async function runServer() {
+  const server = createDevinSearchServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Devin Search MCP 服务器已成功启动 (stdio)");
+}

package/src/response-repair.mjs

@@ -0,0 +1,119 @@
+/**
+ * 响应解析与容错修复模块
+ * 借鉴 fast-context-mcp 的模型输出深度解析与括号平衡修复能力
+ */
+
+/**
+ * 修复常见畸形或截断的 JSON 文本
+ */
+export function repairJson(raw) {
+  if (!raw || typeof raw !== "string") return null;
+
+  let text = raw.trim();
+
+  // 1. 去除代码块包裹
+  const codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)(?:```|$)/i);
+  if (codeBlockMatch && codeBlockMatch[1]) {
+    text = codeBlockMatch[1].trim();
+  }
+
+  // 2. 找到第一个有效起始符号 '[' 或 '{'
+  const firstBracket = text.indexOf("[");
+  const firstBrace = text.indexOf("{");
+  let startIdx = -1;
+  let expectType = "";
+
+  if (firstBracket !== -1 && (firstBrace === -1 || firstBracket < firstBrace)) {
+    startIdx = firstBracket;
+    expectType = "array";
+  } else if (firstBrace !== -1) {
+    startIdx = firstBrace;
+    expectType = "object";
+  }
+
+  if (startIdx === -1) return null;
+  text = text.slice(startIdx);
+
+  // 3. 统计括号深度并补全缺失闭合
+  const stack = [];
+  let inString = false;
+  let escapeNext = false;
+  let validEnd = text.length;
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) continue;
+
+    if (char === "{" || char === "[") {
+      stack.push(char);
+    } else if (char === "}") {
+      if (stack[stack.length - 1] === "{") {
+        stack.pop();
+        if (stack.length === 0) {
+          validEnd = i + 1;
+          break;
+        }
+      }
+    } else if (char === "]") {
+      if (stack[stack.length - 1] === "[") {
+        stack.pop();
+        if (stack.length === 0) {
+          validEnd = i + 1;
+          break;
+        }
+      }
+    }
+  }
+
+  let slice = text.slice(0, validEnd);
+
+  // 补齐字符串引号
+  if (inString) {
+    slice += '"';
+  }
+
+  // 补齐末尾闭合括号
+  while (stack.length > 0) {
+    const top = stack.pop();
+    slice += top === "{" ? "}" : "]";
+  }
+
+  // 移除数组或对象末尾的多余逗号
+  slice = slice.replace(/,\s*([}\]])/g, "$1");
+
+  return slice;
+}
+
+/**
+ * 健壮的 JSON 解析器，先原生解析，失败则尝试修复
+ */
+export function parseJsonWithRepair(raw) {
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    const repaired = repairJson(raw);
+    if (!repaired) return null;
+    try {
+      return JSON.parse(repaired);
+    } catch {
+      return null;
+    }
+  }
+}

package/src/search.mjs

@@ -0,0 +1,149 @@
+/**
+ * Devin 核心网页搜索模块
+ * 深度解析、结构化提炼与重试机制 (对齐 fast-context-mcp 规范)
+ */
+
+import { execFile } from "node:child_process";
+import { findDevinExecutable } from "./detector.mjs";
+import { searchCache } from "./cache.mjs";
+import { parseJsonWithRepair } from "./response-repair.mjs";
+
+/**
+ * 文本正则提取兜底逻辑
+ */
+function fallbackParseResults(text) {
+  const results = [];
+  const lines = text.split(/\r?\n/);
+  let currentItem = null;
+
+  for (const line of lines) {
+    const urlMatch = line.match(/https?:\/\/[^\s)\]"'>]+/);
+    if (urlMatch) {
+      if (currentItem) results.push(currentItem);
+      currentItem = {
+        title: line.replace(urlMatch[0], "").replace(/^[-*#\d.\s]+/, "").trim() || "网页结果",
+        url: urlMatch[0],
+        snippet: "",
+      };
+    } else if (currentItem && line.trim()) {
+      currentItem.snippet += (currentItem.snippet ? " " : "") + line.trim();
+    }
+  }
+  if (currentItem) results.push(currentItem);
+  return results;
+}
+
+/**
+ * 执行带重试的 Devin 网页搜索
+ */
+export async function executeWebSearch({
+  query,
+  num_results = 5,
+  detailed = false,
+  timeoutMs = 35000,
+  maxRetries = 1,
+}) {
+  if (!query || typeof query !== "string") {
+    throw new Error("请提供有效的搜索关键词 (query)");
+  }
+
+  const startTime = Date.now();
+  const cacheKey = searchCache.generateKey("web_search", query, { num_results, detailed });
+  const cached = searchCache.get(cacheKey);
+  if (cached) {
+    return {
+      ...cached,
+      latencyMs: 0,
+      cached: true,
+    };
+  }
+
+  const devinExe = findDevinExecutable();
+  if (!devinExe) {
+    throw new Error("未检测到本地 Devin 安装，请确认已安装 Devin 或配置 DEVIN_PATH 环境变量。");
+  }
+
+  let prompt = "";
+  if (!detailed) {
+    prompt = `请调用内置的 web_search 工具搜索 "${query}"（返回约 ${num_results} 条）。不要输出任何多余寒暄、说明或额外文本，只输出一个标准的 JSON 数组，每个元素包含 "title", "url", "snippet"。`;
+  } else {
+    prompt = `请调用内置的 web_search 工具深度搜索 "${query}"。请输出：1. 检索到的核心网页列表（包含标题、完整 URL、核心摘录）；2. 针对该查询的综合结论分析与技术要点提炼。以清晰的 Markdown 格式呈现。`;
+  }
+
+  const runAttempt = () =>
+    new Promise((resolve, reject) => {
+      execFile(
+        devinExe,
+        ["--permission-mode", "dangerous", "--respect-workspace-trust", "false", "-p", prompt],
+        {
+          timeout: timeoutMs,
+          maxBuffer: 10 * 1024 * 1024,
+          encoding: "utf-8",
+          env: { ...process.env, DEVIN_PERMISSION_MODE: "dangerous" },
+        },
+        (error, stdout, stderr) => {
+          if (error) {
+            if (error.killed) {
+              reject(new Error(`搜索超时 (超过 ${timeoutMs / 1000}s)`));
+            } else {
+              reject(new Error(`执行搜索失败: ${error.message}\n${stderr || ""}`));
+            }
+            return;
+          }
+          resolve(stdout.trim());
+        }
+      );
+    });
+
+  let rawOutput = "";
+  let lastErr = null;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      rawOutput = await runAttempt();
+      break;
+    } catch (err) {
+      lastErr = err;
+      if (attempt < maxRetries) {
+        await new Promise((r) => setTimeout(r, 1000));
+      }
+    }
+  }
+
+  if (!rawOutput && lastErr) {
+    throw lastErr;
+  }
+
+  let structuredResults = [];
+  let summary = "";
+
+  if (!detailed) {
+    const parsed = parseJsonWithRepair(rawOutput);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+      structuredResults = parsed.slice(0, num_results).map((item) => ({
+        title: item.title || item.name || "网页结果",
+        url: item.url || item.link || "",
+        snippet: item.snippet || item.description || item.summary || "",
+      }));
+    } else {
+      structuredResults = fallbackParseResults(rawOutput).slice(0, num_results);
+    }
+  } else {
+    summary = rawOutput;
+    structuredResults = fallbackParseResults(rawOutput).slice(0, num_results);
+  }
+
+  const latencyMs = Date.now() - startTime;
+  const resultPayload = {
+    query,
+    count: structuredResults.length,
+    results: structuredResults,
+    summary: summary || undefined,
+    latencyMs,
+    config: `query="${query}" num_results=${num_results} detailed=${detailed}`,
+    cached: false,
+  };
+
+  searchCache.set(cacheKey, resultPayload);
+  return resultPayload;
+}