argo-search 2.9.7 → 2.9.8

package/scripts/mcp_launch.sh

@@ -38,15 +38,17 @@ set +a
 _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_METASO_API_KEY ARGO_OCTEN_API_KEY\
- ARGO_PROXY ARGO_QWEATHER_KEY ARGO_TAVILY_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_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 WEB_SEARCH_API_KEY WEREAD_API_KEY\
- WOLFRAM_APPID ZHIHU_ACCESS_SECRET"
+ 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 个未设键让每个宿主会话白付百毫秒级纯开销。改为一次

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)

package/scripts/mcp_server.py

@@ -137,18 +137,17 @@ def call_mode(tool: str, payload: str) -> int:
 
 # ── 入口 ──────────────────────────────────────────────────────────────────────
 
-if __name__ == "__main__":
+def main(argv: list[str] | None = None) -> int:
+    args = sys.argv[1:] if argv is None else argv
     # Windows GBK 防线（PEP 540）：非 UTF-8 模式直接跑本文件时，重新以
     # -X utf8 启动自己，保证中文 JSON 读取与 stderr 输出不因控制台编码崩。
     if not sys.flags.utf8_mode and os.name == "nt":
         import subprocess as _sp
         _rc = _sp.run(
-            [sys.executable, "-X", "utf8", __file__, *sys.argv[1:]],
+            [sys.executable, "-X", "utf8", __file__, *args],
             env={**os.environ, "PYTHONUTF8": "1"},
         ).returncode
-        # 子进程的退出码就是本进程的退出码：无条件 sys.exit(0) 会把失败
-        # 伪装成成功，调用方（DSH 原生工具/脚本）据此渲染必然说谎
-        sys.exit(_rc)
+        return _rc
     # env 文件 → os.environ 同步（只填缺失，不覆盖已有值）：非 mcp_launch.sh
     # 启动（直跑本文件/裸宿主直连）时密钥仍能到位，读取方零改动
     try:
@@ -165,7 +164,7 @@ if __name__ == "__main__":
     # 未知旗标显式报错（exit 2）：此前任何拼错的 flag 都静默落进 stdio 模式
     # ——stdio 挂着等 stdin，调用方看到的是「卡死」而不是「参数错了」。
     _skip = 0
-    for _a in sys.argv[1:]:
+    for _a in args:
         if _skip:
             _skip -= 1
             continue
@@ -174,16 +173,22 @@ if __name__ == "__main__":
             continue
         if _a.startswith("-") and _a != "--test":
             print(_dumps({"error": f"未知参数: {_a}（支持 --test / --call <tool> [json]；无参数 = stdio 服务）"}))
-            sys.exit(2)
-    if "--test" in sys.argv:
+            return 2
+    if "--test" in args:
         test_mode()
-    elif "--call" in sys.argv:
-        _i = sys.argv.index("--call")
-        _tool = sys.argv[_i + 1] if len(sys.argv) > _i + 1 else ""
+        return 0
+    elif "--call" in args:
+        _i = args.index("--call")
+        _tool = args[_i + 1] if len(args) > _i + 1 else ""
         if not _tool:
             print(_dumps({"error": "usage: mcp_server.py --call <tool> [json-args]"}))
-            sys.exit(2)
-        _payload = sys.argv[_i + 2] if len(sys.argv) > _i + 2 else "{}"
-        sys.exit(call_mode(_tool, _payload))
+            return 2
+        _payload = args[_i + 2] if len(args) > _i + 2 else "{}"
+        return call_mode(_tool, _payload)
     else:
         run_stdio()
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/mcp_setup.py

@@ -87,12 +87,36 @@ def _resolve(path_str: str) -> Path:
     return p
 
 
+def _client_config_path(client: dict[str, Any]) -> str:
+    """获取当前操作系统对应的配置文件路径声明。"""
+    plat = sys.platform
+    if plat == "darwin" and "config_path_darwin" in client:
+        return client["config_path_darwin"]
+    if plat == "win32" and "config_path_win32" in client:
+        return client["config_path_win32"]
+    if plat.startswith("linux") and "config_path_linux" in client:
+        return client["config_path_linux"]
+    return client.get("config_path", "")
+
+
+def _client_detects(client: dict[str, Any]) -> list[str]:
+    """获取当前操作系统对应的客户端探测路径列表。"""
+    plat = sys.platform
+    if plat == "darwin" and "detect_darwin" in client:
+        return client["detect_darwin"]
+    if plat == "win32" and "detect_win32" in client:
+        return client["detect_win32"]
+    if plat.startswith("linux") and "detect_linux" in client:
+        return client["detect_linux"]
+    return client.get("detect") or []
+
+
 def detect(client: dict[str, Any]) -> bool:
     """客户端是否已安装（detect 路径任一存在）。无 detect 字段则看 config_path 父目录。"""
-    detects = client.get("detect") or []
+    detects = _client_detects(client)
     if detects:
         return any(_resolve(d).exists() for d in detects)
-    return _resolve(client["config_path"]).parent.exists()
+    return _resolve(_client_config_path(client)).parent.exists()
 
 
 # ── MCP 命令模板 ────────────────────────────────────────────────────────
@@ -168,7 +192,7 @@ def _json_read(path: Path) -> dict[str, Any]:
 
 def _inject_json(client: dict[str, Any], entry: dict[str, Any]) -> str:
     """JSON 客户端注入：合并 entry，保留未改动子树。"""
-    path = _resolve(client["config_path"])
+    path = _resolve(_client_config_path(client))
     config = _json_read(path)
     servers_key = client["servers_key"]
     if not isinstance(config.get(servers_key), dict):
@@ -179,7 +203,7 @@ def _inject_json(client: dict[str, Any], entry: dict[str, Any]) -> str:
 
 def _remove_json(client: dict[str, Any]) -> str | None:
     """JSON 客户端移除 argo entry。返回新内容；无 entry 返回 None。"""
-    path = _resolve(client["config_path"])
+    path = _resolve(_client_config_path(client))
     if not path.exists():
         return None
     config = _json_read(path)
@@ -216,7 +240,7 @@ def _toml_block(client: dict[str, Any], entry: dict[str, Any]) -> str:
 
 def _inject_toml(client: dict[str, Any], entry: dict[str, Any]) -> str:
     """TOML 客户端注入：行级 append section。已存在则报错（不覆盖，避免破坏）。"""
-    path = _resolve(client["config_path"])
+    path = _resolve(_client_config_path(client))
     existing = path.read_text(encoding="utf-8") if path.exists() else ""
     servers_key = client["servers_key"]
     marker = f"[{servers_key}.{ENTRY_NAME}]"
@@ -232,7 +256,7 @@ def _inject_toml(client: dict[str, Any], entry: dict[str, Any]) -> str:
 
 def _remove_toml(client: dict[str, Any]) -> str | None:
     """TOML 客户端移除：删除 [mcp_servers.argo] section。"""
-    path = _resolve(client["config_path"])
+    path = _resolve(_client_config_path(client))
     if not path.exists():
         return None
     text = path.read_text(encoding="utf-8")
@@ -260,7 +284,7 @@ def _remove_toml(client: dict[str, Any]) -> str | None:
 # ── 诊断 ────────────────────────────────────────────────────────────────
 
 def _entry_present(client: dict[str, Any]) -> bool:
-    path = _resolve(client["config_path"])
+    path = _resolve(_client_config_path(client))
     if not path.exists():
         return False
     fmt = client.get("format", "json")
@@ -322,7 +346,7 @@ def cmd_inject(clients: list[dict[str, Any]], flags: list[str], dry_run: bool) -
         return
     print(f"将注入 {', '.join(c['name'] for c in targets)} ...\n")
     for c in targets:
-        path = _resolve(c["config_path"])
+        path = _resolve(_client_config_path(c))
         fmt = c.get("format", "json")
         entry = _mcp_command(c)
         try:
@@ -348,7 +372,7 @@ def cmd_undo(clients: list[dict[str, Any]], flags: list[str], dry_run: bool) ->
         return
     print(f"将还原 {', '.join(c['name'] for c in targets)} ...\n")
     for c in targets:
-        path = _resolve(c["config_path"])
+        path = _resolve(_client_config_path(c))
         fmt = c.get("format", "json")
         try:
             if dry_run:

package/scripts/mcp_tools.py

@@ -164,6 +164,7 @@ TOOLS = [
                 "focus": {"type": "string", "description": "BM25 聚焦查询词：只返回相关段落，省 token（仅 mode=text）"},
                 "max_chars": {"type": "integer", "description": "返回正文最大字符数", "default": 8000, "minimum": 500, "maximum": 50000},
                 "use_browser": {"type": "boolean", "description": "强制用反检测浏览器（HTTP 失败时已自动升级）", "default": False},
+                "include_links": {"type": "boolean", "description": "附带正文内链接（最多 30 条；默认只回 links_count，省 token）", "default": False},
             },
             "required": ["url"],
         },

package/scripts/mcp_transport.py

@@ -22,7 +22,7 @@ except Exception:  # pragma: no cover
 
 # 版本来源：与 package.json / SKILL.md 保持一致（发布时统一升版；
 # tests/test_consistency_gates.py 会四端对账，漂移即红）
-ARGO_MCP_VERSION = "2.9.7"
+ARGO_MCP_VERSION = "2.9.8"
 
 _response_format = "content-length"  # 根据客户端请求自动切换
 

package/scripts/mcp_warm.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""mcp_warm.py — MCP 核心预热、连接池预建与社交抓取并发编排。
+
+拆分自 mcp_handlers.py：隔离后台异步预热线程模型与社交平台并发调度。
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+from typing import Any
+
+_warm_started = False
+
+
+def _prewarm_anysearch_connection() -> None:
+    """在 warm 线程里预建 anysearch 的隧道连接（2026-10-18）。"""
+    if os.environ.get("ARGO_NO_PREWARM", "").strip() not in ("", "0"):
+        return
+    try:
+        import urllib.parse
+        from conn_pool import give_back, key_for, stats as pool_stats
+        from net_proxy import open_connection, resolve_proxy
+        if not pool_stats().get("enabled"):
+            return
+        url = "https://api.anysearch.com/mcp"
+        parsed = urllib.parse.urlparse(url)
+        proxy_url = resolve_proxy(url)
+        conn, _via = open_connection(parsed, 8.0, proxy_url)
+        conn.connect()
+        give_back(key_for(parsed, proxy_url), conn)
+    except Exception as e:
+        sys.stderr.write(f"[argo-mcp] prewarm-skip: {type(e).__name__}: {e}\n")
+
+
+def _warm_core_async(lazy_cached_fn, get_cache_fn) -> None:
+    """initialize 后后台预热 search+cache，摊平首次 tools/call 延迟。"""
+    global _warm_started
+    if _warm_started:
+        return
+    _warm_started = True
+
+    def _run() -> None:
+        t0 = __import__("time").time()
+        try:
+            lazy_cached_fn("search")
+            get_cache_fn()
+            try:
+                from route_domains import warm_compiled_domains
+                warm_compiled_domains()
+            except Exception:
+                pass
+            _prewarm_anysearch_connection()
+            ms = int((__import__("time").time() - t0) * 1000)
+            sys.stderr.write(f"[argo-mcp] warm-core ok {ms}ms\n")
+        except Exception as e:
+            sys.stderr.write(f"[argo-mcp] warm-core fail: {type(e).__name__}: {e}\n")
+        sys.stderr.flush()
+
+    threading.Thread(target=_run, name="argo-mcp-warm", daemon=True).start()
+
+
+def _resolve_research_profile(arguments: dict[str, Any], lazy_cached_fn) -> tuple[dict[str, Any] | None, str | None]:
+    """解析 topic profile；全部在 argo 内，不加载外部 skill。"""
+    try:
+        profiles = lazy_cached_fn("topic_research_profiles")
+    except Exception:
+        return None, None
+    if not profiles:
+        return None, None
+    topic = arguments.get("topic")
+    key = None
+    if topic:
+        prof = profiles.get_profile(str(topic))
+        if prof:
+            raw = str(topic).strip()
+            key = profiles.ALIASES.get(raw) or profiles.ALIASES.get(raw.lower()) or raw.lower()
+            return prof, key
+        return None, None
+    if arguments.get("auto_topic", True):
+        key = profiles.detect_topic_from_query(arguments.get("query") or "")
+        if key:
+            return profiles.get_profile(key), key
+    return None, None
+
+
+def _search_social_platforms(
+    platforms: list[str], query: str, n: int, timeout: float = 20.0,
+    lazy_cached_fn=None,
+) -> tuple[dict[str, list], list[str], list[str]]:
+    """并行抓取多社交平台（MCP 热路径）。"""
+    platform_results: dict[str, list] = {}
+    errors: list[str] = []
+    engines_used: list[str] = []
+
+    def _one(platform: str) -> tuple[str, list, str | None]:
+        module_name = platform.replace("-", "_") + "_engine"
+        try:
+            mod = lazy_cached_fn(f"social_engines.{module_name}")
+            return platform, mod.search(query, n=n), None
+        except ImportError:
+            return platform, [], f"Platform {platform} not available (module social_engines.{module_name})"
+        except Exception as e:
+            return platform, [], f"{platform}: {str(e)[:100]}"
+
+    workers = min(max(len(platforms), 1), 4)
+    import concurrent.futures
+    ex = concurrent.futures.ThreadPoolExecutor(max_workers=workers)
+    futs = {ex.submit(_one, p): p for p in platforms}
+    try:
+        for fut in concurrent.futures.as_completed(futs, timeout=timeout):
+            platform, results, err = fut.result()
+            platform_results[platform] = results
+            if err:
+                errors.append(err)
+            elif results is not None:
+                engines_used.append(platform)
+    except concurrent.futures.TimeoutError:
+        for fut, platform in futs.items():
+            if not fut.done():
+                fut.cancel()
+                platform_results[platform] = []
+                errors.append(f"{platform}: timeout (>{timeout}s)")
+    finally:
+        ex.shutdown(wait=False, cancel_futures=True)
+    return platform_results, engines_used, errors