argo-search 1.0.1 → 2.9.8

package/scripts/mcp_launch.sh

@@ -0,0 +1,124 @@
+#!/bin/sh
+# argo MCP 启动器 —— 保证任何客户端、任何启动上下文都拿到引擎密钥。
+#
+# 背景（2026-08-29）：各客户端 server 的密钥来自「宿主 app 启动时的环境」，
+# 上下文不同密钥就不同（有的 8 个全有、有的全无），且 launchctl setenv
+# 重启即失效。此启动器把密钥收敛到唯一真源文件，启动时注入：
+#   1. ~/.config/argo/env（chmod 600，勿入库勿分享）——唯一真源
+#   2. 系统域兜底：macOS 走 launchctl getenv，其它平台无此层、直接跳过
+# 提前恢复配额/换 key：改 env 文件后重启对应客户端即可，零配置分散维护。
+#
+# 跨平台（2026-09-15）：原版是 `#!/bin/zsh` + `dscl` + `${(P)k}` + `${0:A:h}`
+# + 写死 `/opt/homebrew/bin/python3`，只在装了 Homebrew 的 macOS 上成立。
+# 而 `mcp_setup.py` 把本脚本路径写成 MCP 客户端的 command（10 处引用），
+# 于是 Linux / Windows-WSL 用户接 MCP 的第一步就是
+# `bad interpreter: /bin/zsh`——不是配置错，是脚本根本起不来。
+# 改用 POSIX sh + 解释器探测后，macOS 本机行为不变（同一个 env 文件、同一层
+# launchctl 兜底、同一批透传名单），其余平台从「拉不起来」变成「能起」。
+
+# 某些宿主（如 dsh web）以净化环境 spawn MCP，HOME 可能缺失——先兜底
+if [ -z "$HOME" ]; then
+  if command -v dscl >/dev/null 2>&1; then                 # macOS
+    HOME="$(dscl . -read "/Users/$(id -un)" NFSHomeDirectory 2>/dev/null | awk '{print $2}')"
+  elif command -v getent >/dev/null 2>&1; then             # Linux
+    HOME="$(getent passwd "$(id -un)" | cut -d: -f6)"
+  fi
+  [ -n "$HOME" ] && export HOME
+fi
+
+ENV_FILE="${HOME}/.config/argo/env"
+# set -a 仅覆盖 env 文件加载这一行，内部变量不导出
+set -a
+[ -f "$ENV_FILE" ] && . "$ENV_FILE"
+set +a
+
+# 透传名单单一真源：launchctl print 批量路径与 getenv 回退路径共用这一份
+# （与 engine_env.KNOWN_ENV_ALIASES 展开 + 代理变量对齐，
+# tests/test_launch_passthrough_alignment.py 锁两表一致，改名单两处同步）
+_ARGO_PASSTHROUGH_KEYS="ALL_PROXY ANYSEARCH_API_KEY ARGO_ANYSEARCH_API_KEY ARGO_BOCHA_API_KEY\
+ ARGO_BRAVE_API_KEY ARGO_BYTED_API_KEY ARGO_EASTMONEY_APIKEY\
+ ARGO_EXA_API_KEY ARGO_FELO_API_KEY ARGO_FIRECRAWL_API_KEY\
+ ARGO_GITHUB_TOKEN ARGO_JEV_API_KEY ARGO_METASO_API_KEY\
+ ARGO_OCTEN_API_KEY ARGO_PROXY ARGO_QWEATHER_KEY\
+ ARGO_TAVILY_API_KEY TYPESAFE_API_KEY\
+ ARGO_WEB_SEARCH_API_KEY ARGO_WEREAD_API_KEY\
+ ARGO_WOLFRAM_APPID ARGO_YUANBAO_API_KEY ARGO_ZHIHU_ACCESS_SECRET\
+ BOCHA_API_KEY BRAVE_API_KEY EASTMONEY_APIKEY EXA_API_KEY\
+ FELO_API_KEY FIRECRAWL_API_KEY GITHUB_TOKEN HTTPS_PROXY\
+ HTTP_PROXY METASO_API_KEY NO_PROXY OCTEN_API_KEY\
+ QWEATHER_KEY TAVILY_API_KEY TENCENTCLOUD_WSA_APIKEY\
+ WEB_SEARCH_API_KEY WEREAD_API_KEY WOLFRAM_APPID\
+ YUANBAO_API_KEY ZHIHU_ACCESS_SECRET"
+
+# launchctl 兜底（macOS）：旧实现逐键 spawn `launchctl getenv`——实测每次
+# 4-20ms，名单里 ~30 个未设键让每个宿主会话白付百毫秒级纯开销。改为一次
+# `launchctl print gui/$UID` 读整个域环境（实测热态 ~30ms）：environment 段
+# 的 "KEY => value" 行与 getenv 同源（setenv 探针实测，含空格值一致）。
+# print 不可用（非 macOS / 特殊上下文）时回退旧逐键 getenv，行为同 08-29 版。
+_lc_vals=""
+if command -v launchctl >/dev/null 2>&1; then
+  _lc_vals="$(launchctl print "gui/$(id -u)" 2>/dev/null | LC_ALL=C awk -v keys="$_ARGO_PASSTHROUGH_KEYS" '
+    BEGIN { n = split(keys, a, " "); for (i = 1; i <= n; i++) want[a[i]] = 1 }
+    /^[[:space:]]*environment[[:space:]]*=[[:space:]]*\{/ { e = 1; next }
+    e && /^[[:space:]]*\}/ { exit }
+    e && / => / {
+      i = index($0, " => ")
+      k = substr($0, 1, i - 1)
+      sub(/^[[:space:]]+/, "", k)
+      if (k in want) print k "\t" substr($0, i + 4)
+    }')"
+fi
+if [ -n "$_lc_vals" ]; then
+  # 名单内已设的键逐条导出；env 文件/父环境已给的键不覆盖（语义同旧循环）
+  while IFS="	" read -r k v; do
+    eval "cur=\${$k}"
+    if [ -z "$cur" ] && [ -n "$v" ]; then
+      export "$k=$v"
+    fi
+  done <<_ARGO_LC_EOF
+$_lc_vals
+_ARGO_LC_EOF
+else
+  for k in $_ARGO_PASSTHROUGH_KEYS; do
+    if command -v launchctl >/dev/null 2>&1; then
+      # POSIX 间接展开（zsh 的 ${(P)k} 在 sh 下不存在，eval 是等价写法）
+      eval "cur=\${$k}"
+      if [ -z "$cur" ]; then
+        v="$(launchctl getenv "$k" 2>/dev/null)"
+        [ -n "$v" ] && export "$k=$v"
+      fi
+    fi
+  done
+fi
+
+# 脚本所在目录的绝对路径（POSIX 写法，替代 zsh 的 ${0:A:h}）
+SCRIPT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+
+# 解释器：ARGO_PYTHON 显式指定优先（客户端配置可覆盖）；否则自动探测，取第一个
+# 同时满足「版本 ≥3.9」且「能导入 PyYAML」的——版本下限与 bin/argo 的 MIN_PYTHON
+# 一致（改一处就要改另一处）。为什么不是更高的版本：早期这里写 3.10，理由是
+# 「脚本用了 `X | None`」，但实测全仓 0 处该写法。而配置/引擎声明都靠 PyYAML
+# 解析，版本够却没装 yaml 的解释器选了也只能用残缺的内置默认配置——所以这两点
+# 必须**同时**判，少判一个就会选到跑不动的解释器（bin/argo 曾因此把 3.9 选中
+# 并写进缓存）。报错最终都落在客户端日志里，用户看到的是「MCP server 未就绪」，
+# 所以探测阶段就把不可用的解释器跳过。
+# 全都不达标时回落 python3：宁可让错误信息可读，也不抛「找不到解释器」。
+# ARGO_PYTHON 显式指定同样要过「版本 + PyYAML」双判据（2026-10-02 补齐）：
+# 此前只查存在性，把无 yaml 的解释器写进 env 文件会带着残缺配置起服务，
+# 宿主只看到「MCP server 未就绪」——与下方自动探测同一条判据。
+if [ -n "$ARGO_PYTHON" ] && command -v "$ARGO_PYTHON" >/dev/null 2>&1 \
+   && "$ARGO_PYTHON" -c 'import sys, yaml; sys.exit(0 if sys.version_info >= (3, 9) else 1)' >/dev/null 2>&1; then
+  PY="$ARGO_PYTHON"
+else
+  PY=""
+  for c in python3 python3.14 python3.13 python3.12 python3.11 python3.10 python3.9 python; do
+    p="$(command -v "$c" 2>/dev/null)" || continue
+    if "$p" -c 'import sys, yaml; sys.exit(0 if sys.version_info >= (3, 9) else 1)' >/dev/null 2>&1; then
+      PY="$p"
+      break
+    fi
+  done
+  [ -n "$PY" ] || PY="python3"
+fi
+
+exec "$PY" -u "${SCRIPT_DIR}/mcp_server.py" "$@"

package/scripts/mcp_local.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""mcp_local.py — MCP 本地文件检索、受限预览与可复算沙箱。
+
+拆分自 mcp_handlers.py：隔离本地文件系统访问、白名单审查、seek 定位与安全执行沙箱。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+from typing import Any
+
+from mcp_compact import _trim_snippet
+
+_LOCAL_READ_ALLOWED_EXTS = {
+    ".md", ".txt", ".csv", ".tsv", ".json", ".yaml", ".yml", ".log",
+    ".py", ".js", ".ts", ".html", ".xml", ".rst", ".ipynb",
+}
+
+
+def _local_read_whitelist() -> list[str]:
+    """白名单目录：ARGO_LOCAL_READ_DIRS（逗号分隔）；没配置就返回空，不放行。"""
+    raw = (os.environ.get("ARGO_LOCAL_READ_DIRS") or "").strip()
+    if not raw:
+        return []
+    return [os.path.realpath(os.path.expanduser(d))
+            for d in raw.split(",") if d.strip()]
+
+
+def _local_read_preview(
+    path: str,
+    max_chars: int = 4000,
+    line_start: int | None = None,
+    line_end: int | None = None,
+) -> tuple[str, dict[str, Any]]:
+    """白名单内文本文件预览（行窗口或字符截断）；越权/二进制拒绝。"""
+    root = os.path.realpath(os.path.expanduser(path))
+    allowed = _local_read_whitelist()
+    if not allowed:
+        raise PermissionError(
+            "本地读取未配置白名单：设 ARGO_LOCAL_READ_DIRS=目录1,目录2（没配置就不放行）"
+        )
+    if not any(root == d or root.startswith(d + os.sep) for d in allowed):
+        raise PermissionError(f"路径不在白名单目录内: {path}")
+    if not os.path.isfile(root):
+        raise FileNotFoundError(f"文件不存在: {path}")
+    ext = os.path.splitext(root)[1].lower()
+    if ext not in _LOCAL_READ_ALLOWED_EXTS:
+        raise PermissionError(f"仅支持文本类文件预览（{ext} 不支持；pdf 走其他路径）")
+    size = os.path.getsize(root)
+    if size > 4 * 1024 * 1024:
+        raise PermissionError("文件超过 4MB，拒绝预览（请缩小范围或改用搜索）")
+
+    with open(root, encoding="utf-8", errors="replace") as f:
+        full = f.read()
+    total_lines = full.count("\n") + (1 if full and not full.endswith("\n") else 0)
+    if line_start is not None or line_end is not None:
+        start = max(1, int(line_start or 1))
+        end = int(line_end) if line_end else start + 200
+        lines = full.splitlines(keepends=True)[(start - 1): end]
+        content = "".join(lines)
+        lines_slice = (start, start + len(lines) - 1)
+    else:
+        content = full
+        lines_slice = None
+
+    truncated = len(content) > max_chars
+    if truncated:
+        content = content[:max_chars]
+    return content, {
+        "path": root,
+        "chars": len(content),
+        "lines": (lines_slice[1] - lines_slice[0] + 1) if lines_slice else None,
+        "total_lines": total_lines,
+        "is_preview": truncated or lines_slice is not None,
+    }
+
+
+def _seek_py() -> str:
+    """定位 local-seek 的 seek.py（安装感知、唯一来源，见 seek_locator）。"""
+    from seek_locator import resolve_seek_py
+    return resolve_seek_py()
+
+
+def handle_local_search(
+    arguments: dict[str, Any],
+    pretty: bool = False,
+    ok_fn=None,
+    clamp_int_fn=None,
+    lazy_cached_fn=None,
+) -> dict[str, Any]:
+    """argo_local_search 实现：本地文件搜索。"""
+    query = str(arguments.get("query", "")).strip()
+
+    def _local_err(msg: str) -> dict:
+        return ok_fn({"query": query, "engine": "local_files", "count": 0, "results": [],
+                     "errors": [msg]}, pretty=pretty)
+
+    if not query:
+        return _local_err("query 不能为空")
+    path = str(arguments.get("path", "~"))
+    max_results = clamp_int_fn(arguments.get("max_results", 5), 5, 1, 20)
+    exact = bool(arguments.get("exact", False))
+
+    # 宽泛根守卫
+    try:
+        if lazy_cached_fn("local_seek")._is_broad_local_root(os.path.expanduser(path)):
+            return _local_err("路径过宽（home / 根目录），扫全盘既慢又失准，已拒绝；请传具体目录")
+    except Exception as e:
+        sys.stderr.write(
+            f"[argo-mcp] local_search 宽泛根守卫不可用（{type(e).__name__}），fail-open\n")
+
+    payload = None
+    try:
+        from local_seek import seek_query_payload
+        payload = seek_query_payload(query, os.path.expanduser(path),
+                                     max_results, exact=exact, time_budget=15)
+    except Exception:
+        payload = None
+
+    if payload is None:
+        seek_py = _seek_py()
+
+        cmd = [sys.executable, seek_py, query, "--path", path, "--json",
+               "--max", str(max_results)]
+        if exact:
+            cmd.append("--exact")
+        try:
+            # 兼容测试 patch mcp_handlers.subprocess.run
+            runner = subprocess.run
+            try:
+                import mcp_handlers
+                runner = getattr(mcp_handlers.subprocess, "run", subprocess.run)
+            except Exception:
+                pass
+
+            proc = runner(
+                cmd, capture_output=True, text=True,
+                encoding="utf-8", errors="replace", timeout=15,
+                env={**os.environ, "PYTHONUTF8": "1"})
+        except Exception as e:
+            return _local_err(f"本地搜索执行失败: {e}")
+        if proc.returncode != 0:
+            msg = (proc.stdout or proc.stderr or "").strip() or "本地搜索无结果"
+            return _local_err(msg)
+        try:
+            payload = json.loads(proc.stdout)
+        except Exception:
+            return _local_err("本地搜索输出解析失败")
+
+    mode = payload.get("mode", "fast")
+    score = 0.9 if mode == "fast" else 0.7
+    results = []
+    for r in payload.get("results") or []:
+        abspath = os.path.abspath(r.get("path", ""))
+        line = r.get("line") or 0
+        results.append({
+            "title": abspath,
+            "url": f"file://{abspath}" + (f"#L{line}" if line else ""),
+            "snippet": _trim_snippet(r.get("snippet"), 120),
+            "source": "local_files", "score": score,
+        })
+    return ok_fn({
+        "query": query, "engine": "local_files", "engines_used": ["local_files"],
+        "count": len(results), "elapsed_ms": payload.get("elapsed_ms"),
+        "cached": False, "mode": mode, "depth": None,
+        "results": results, "errors": [],
+    }, pretty=pretty)
+
+
+def handle_local_read(
+    arguments: dict[str, Any],
+    pretty: bool = False,
+    ok_fn=None,
+    int_param_fn=None,
+) -> dict[str, Any]:
+    """argo_local_read 实现：白名单本地文本预览。"""
+    raw_path = str(arguments.get("path", "")).strip()
+    max_chars = max(200, min(int_param_fn(arguments, "max_chars", 4000), 20000))
+    line_start = arguments.get("line_start")
+    line_end = arguments.get("line_end")
+    if not raw_path:
+        return ok_fn({"path": "", "content": "", "errors": ["path 不能为空"]}, pretty=pretty)
+    try:
+        content, meta = _local_read_preview(
+            raw_path, max_chars=max_chars,
+            line_start=line_start, line_end=line_end,
+        )
+    except Exception as e:
+        return ok_fn({"path": raw_path, "content": "",
+                     "errors": [str(e)]}, pretty=pretty)
+    return ok_fn({
+        "path": meta["path"],
+        "content": content,
+        "chars": meta["chars"],
+        "lines": meta["lines"],
+        "total_lines": meta["total_lines"],
+        "is_preview": meta["is_preview"],
+        "errors": [],
+    }, pretty=pretty)
+
+
+def handle_recompute(
+    arguments: dict[str, Any],
+    pretty: bool = False,
+    ok_fn=None,
+    clamp_int_fn=None,
+) -> dict[str, Any]:
+    """argo_recompute 实现：可复算执行器。"""
+    script = str(arguments.get("script", "")).strip()
+    inputs_raw = arguments.get("file_inputs")
+    inputs = []
+    if isinstance(inputs_raw, str) and inputs_raw.strip():
+        try:
+            inputs = json.loads(inputs_raw)
+        except ValueError:
+            inputs = []
+    elif isinstance(inputs_raw, list):
+        inputs = inputs_raw
+    elif inputs_raw:
+        try:
+            inputs = json.loads(inputs_raw)
+        except (ValueError, TypeError):
+            inputs = []
+    timeout_s = clamp_int_fn(arguments.get("timeout_s", 30), 30, 1, 120)
+    max_mem_mb = clamp_int_fn(arguments.get("max_mem_mb", 512), 512, 64, 4096)
+    allow_exec = bool(arguments.get("allow_exec", False))
+    if not script:
+        return ok_fn({"ok": False, "skipped_reason": "script 为空"}, pretty=pretty)
+    try:
+        from recompute import run_recompute
+        result = run_recompute(
+            script, inputs or None,
+            timeout_s=timeout_s, max_mem_mb=max_mem_mb,
+            allow_exec=allow_exec,
+        )
+    except Exception as e:
+        result = {"ok": False, "skipped_reason": f"执行器异常: {e}"}
+    return ok_fn(result, pretty=pretty)