deepcloak 0.1.0__py3-none-any.whl

deepcloak/__init__.py

@@ -0,0 +1,3 @@
+"""DeepCloak — local-first deep research that reads bot-walled pages."""
+
+__version__ = "0.1.0"

deepcloak/bot_wall_detector.py

@@ -0,0 +1,68 @@
+"""Detect a Bot Wall in a plain HTTP response.
+
+Pure module: ``classify()`` takes a status code, headers, and body and returns a
+``BotWall`` (the kind + the signal that triggered it) or ``None``. A detected
+Bot Wall is what triggers an Escalation in ``fetch_router``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ["BotWall", "classify", "from_response"]
+
+
+@dataclass(frozen=True)
+class BotWall:
+    kind: str  # cloudflare | datadome | turnstile | recaptcha | rate_limit | blocked
+    signal: str  # human-readable reason, recorded in the Evidence Record
+
+
+# Vendor markers checked in the body (lower-cased), strongest signal first.
+_TURNSTILE = ("challenges.cloudflare.com/turnstile", "cf-turnstile")
+_DATADOME = ("captcha-delivery.com", "protected by datadome", "geo.captcha-delivery")
+_RECAPTCHA = ("g-recaptcha", "recaptcha/api.js", "google.com/recaptcha")
+_CLOUDFLARE = (
+    "just a moment",
+    "checking your browser",
+    "/cdn-cgi/challenge-platform",
+    "attention required! | cloudflare",
+)
+
+
+def classify(status_code: int, headers: Mapping[str, str], body: str) -> BotWall | None:
+    body_l = (body or "").lower()
+    hdr_l = {str(k).lower(): str(v).lower() for k, v in dict(headers or {}).items()}
+
+    if any(m in body_l for m in _TURNSTILE):
+        return BotWall("turnstile", "Cloudflare Turnstile widget present")
+    if "datadome" in hdr_l.get("set-cookie", "") or "x-datadome" in hdr_l or any(
+        m in body_l for m in _DATADOME
+    ):
+        return BotWall("datadome", "DataDome challenge present")
+    if any(m in body_l for m in _RECAPTCHA):
+        return BotWall("recaptcha", "reCAPTCHA widget present")
+    if any(m in body_l for m in _CLOUDFLARE):
+        return BotWall("cloudflare", "Cloudflare interstitial challenge")
+    if hdr_l.get("cf-mitigated") == "challenge":
+        return BotWall("cloudflare", "cf-mitigated: challenge header")
+
+    if status_code == 429:
+        return BotWall("rate_limit", "HTTP 429 Too Many Requests")
+    if status_code == 503 and ("cf-ray" in hdr_l or "cloudflare" in body_l):
+        return BotWall("cloudflare", "HTTP 503 from Cloudflare")
+    if status_code == 403:
+        return BotWall("blocked", "HTTP 403 Forbidden")
+
+    return None
+
+
+def from_response(resp: Any) -> BotWall | None:
+    """Convenience wrapper for a requests-style response object."""
+    return classify(
+        status_code=getattr(resp, "status_code", 0),
+        headers=getattr(resp, "headers", {}) or {},
+        body=getattr(resp, "text", "") or "",
+    )

deepcloak/cli.py

@@ -0,0 +1,87 @@
+"""DeepCloak command-line interface."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from . import __version__
+
+__all__ = ["main", "build_parser"]
+
+_SUBCOMMANDS = ("setup", "mcp")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="deepcloak",
+        description="Deep research that reads bot-walled pages.",
+        epilog="Subcommands: 'deepcloak setup' (install stealth browser), "
+        "'deepcloak mcp' (run MCP server).",
+    )
+    p.add_argument("--version", action="version", version=f"deepcloak {__version__}")
+    p.add_argument("query", nargs="?", help="The research question.")
+    p.add_argument("--depth", choices=["quick", "detailed", "report"], default="detailed")
+    p.add_argument("--engine", choices=["duckduckgo", "searxng", "auto"], default=None)
+    p.add_argument("--searxng-url", dest="searxng_url", default=None,
+                   help="SearXNG instance URL (for --engine searxng)")
+    p.add_argument("--stealth", choices=["auto", "always", "off"], default=None)
+    p.add_argument("--respect-robots", action="store_true", dest="respect_robots")
+    p.add_argument("--proxy", default=None)
+    p.add_argument("--provider", default=None,
+                   help="openai/anthropic/gemini/ollama/openai-endpoint")
+    p.add_argument("--model", default=None)
+    p.add_argument("--base-url", dest="base_url", default=None,
+                   help="OpenAI-compatible URL (for openai-endpoint provider)")
+    p.add_argument("--out", default=None, help="Write the report to this file.")
+    return p
+
+
+def _cli_dict(args: argparse.Namespace) -> dict:
+    keys = ("depth", "engine", "stealth", "respect_robots", "proxy",
+            "provider", "model", "base_url", "searxng_url", "out")
+    return {k: getattr(args, k) for k in keys if getattr(args, k) not in (None, False)}
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = sys.argv[1:] if argv is None else list(argv)
+
+    # Subcommands are dispatched manually so the default `deepcloak "<query>"`
+    # form doesn't collide with an argparse subparser positional.
+    if argv and argv[0] == "setup":
+        from .setup import run_setup
+
+        return run_setup()
+    if argv and argv[0] == "mcp":
+        from .mcp_server import serve
+
+        serve()
+        return 0
+
+    args = build_parser().parse_args(argv)
+    if not args.query:
+        build_parser().print_help()
+        return 2
+
+    from .research_core import research
+
+    try:
+        result = research(args.query, cli=_cli_dict(args), verbose=True)
+    except Exception as exc:  # surface a clean message, not a traceback
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    if args.out:
+        with open(args.out, "w", encoding="utf-8") as fh:
+            fh.write(result.report)
+        sidecar = f"{args.out}.evidence.json"
+        with open(sidecar, "w", encoding="utf-8") as fh:
+            fh.write(result.evidence_json)
+        print(f"wrote {args.out} (+ {sidecar})")
+    else:
+        print(result.report)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

deepcloak/config.py

@@ -0,0 +1,168 @@
+"""Resolve runtime settings from CLI args + environment.
+
+Pure module: ``resolve()`` takes plain mappings and returns a frozen ``Settings``.
+No I/O, no imports of the heavy upstreams — so it is trivially testable.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+__all__ = ["ConfigError", "Settings", "resolve"]
+
+
+class ConfigError(Exception):
+    """Raised when settings cannot be resolved (e.g. no LLM credentials)."""
+
+
+# Provider auto-detection precedence: first env var present wins.
+_PROVIDER_ENV: list[tuple[str, str]] = [
+    ("openai", "OPENAI_API_KEY"),
+    ("anthropic", "ANTHROPIC_API_KEY"),
+    ("gemini", "GEMINI_API_KEY"),
+    ("openrouter", "OPENROUTER_API_KEY"),
+]
+_PROVIDER_KEY = dict(_PROVIDER_ENV)
+# Providers that run locally and need no API key.
+_KEYLESS_PROVIDERS = {"ollama", "openai-endpoint"}
+
+_VALID_STEALTH = {"auto", "always", "off"}
+_VALID_DEPTH = {"quick", "detailed", "report"}
+_VALID_ENGINE = {"duckduckgo", "searxng", "auto"}
+
+_DEFAULT_MODEL = {
+    "openai": "gpt-4.1",
+    "anthropic": "claude-sonnet-4-6",
+    "gemini": "gemini-2.5-pro",
+    "openrouter": "openai/gpt-4.1",
+    "ollama": "llama3.1",
+    "openai-endpoint": None,  # local OpenAI-compatible server — model is server-defined
+}
+
+# Our provider name -> the value local-deep-research expects in LDR_LLM_PROVIDER.
+_LDR_PROVIDER = {
+    "openai": "openai",
+    "anthropic": "anthropic",
+    "gemini": "gemini",
+    "openrouter": "openai_endpoint",
+    "ollama": "ollama",
+    "openai-endpoint": "openai_endpoint",
+}
+
+
+@dataclass(frozen=True)
+class Settings:
+    provider: str
+    model: str | None
+    api_key: str | None
+    search_engine: str
+    stealth_mode: str
+    depth: str
+    respect_robots: bool
+    out: str | None
+    proxy: str | None
+    searxng_url: str | None
+    base_url: str | None = None  # for provider "openai-endpoint" (local OpenAI-compatible)
+
+    def to_ldr_env(self) -> dict[str, str]:
+        """Map resolved settings to the LDR_* environment variables LDR reads."""
+        env: dict[str, str] = {
+            "LDR_LLM_PROVIDER": _LDR_PROVIDER[self.provider],
+            # DeepCloak's whole point is reading full pages (and Bypassing walls to
+            # do it), so we always fetch full content — never snippet-only.
+            "LDR_SEARCH_SNIPPETS_ONLY": "false",
+        }
+        if self.model:
+            env["LDR_LLM_MODEL"] = self.model
+        if self.provider == "openai-endpoint":
+            if self.base_url:
+                env["LDR_LLM_OPENAI_ENDPOINT_URL"] = self.base_url
+            # llama.cpp / vLLM ignore the key, but LDR requires a non-empty one.
+            env["LDR_LLM_OPENAI_ENDPOINT_API_KEY"] = self.api_key or "local"
+        # Pass the credential through under its standard name (langchain reads these).
+        if self.api_key and self.provider in _PROVIDER_KEY:
+            env[_PROVIDER_KEY[self.provider]] = self.api_key
+        if self.search_engine == "searxng" and self.searxng_url:
+            env["LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL"] = self.searxng_url
+        return env
+
+    def to_ldr_overrides(self) -> dict:
+        """Settings as an LDR settings-snapshot override dict (the supported API path).
+
+        Critically sets ``search.snippets_only=False`` so the research loop fetches
+        full pages — which is what routes through the stealth shim and Bypasses walls.
+        """
+        o: dict[str, object] = {
+            "llm.provider": _LDR_PROVIDER[self.provider],
+            "search.snippets_only": False,
+            "search.tool": self.search_engine,
+        }
+        if self.model:
+            o["llm.model"] = self.model
+        if self.provider == "openai-endpoint":
+            if self.base_url:
+                o["llm.openai_endpoint.url"] = self.base_url
+            o["llm.openai_endpoint.api_key"] = self.api_key or "local"
+        elif self.api_key and self.provider in _PROVIDER_KEY:
+            o[f"llm.{self.provider}.api_key"] = self.api_key
+        if self.search_engine == "searxng" and self.searxng_url:
+            o["search.engine.web.searxng.default_params.instance_url"] = self.searxng_url
+        return o
+
+
+def _resolve_provider(cli: Mapping, env: Mapping) -> str:
+    provider = cli.get("provider")
+    if provider:
+        return provider
+    for name, key in _PROVIDER_ENV:
+        if env.get(key):
+            return name
+    wanted = ", ".join(key for _, key in _PROVIDER_ENV)
+    raise ConfigError(
+        "No LLM credentials found. Set one of: "
+        f"{wanted} (or pass --provider ollama for a local model)."
+    )
+
+
+def _validate(value: str, valid: set[str], label: str) -> str:
+    if value not in valid:
+        raise ConfigError(f"Invalid {label}: {value!r}. Choose one of {sorted(valid)}.")
+    return value
+
+
+def resolve(cli: Mapping, env: Mapping) -> Settings:
+    """Resolve effective settings. Precedence: CLI flags > environment."""
+    provider = _resolve_provider(cli, env)
+    api_key = None
+    if provider not in _KEYLESS_PROVIDERS:
+        api_key = env.get(_PROVIDER_KEY.get(provider, ""))
+
+    model = cli.get("model") or env.get("DEEPCLOAK_MODEL") or _DEFAULT_MODEL.get(provider)
+    search_engine = _validate(cli.get("engine") or "duckduckgo", _VALID_ENGINE, "search engine")
+    stealth_mode = _validate(cli.get("stealth") or "auto", _VALID_STEALTH, "stealth mode")
+    depth = _validate(cli.get("depth") or "detailed", _VALID_DEPTH, "depth")
+    searxng_url = cli.get("searxng_url") or env.get(
+        "LDR_SEARCH_ENGINE_WEB_SEARXNG_DEFAULT_PARAMS_INSTANCE_URL"
+    )
+
+    base_url = cli.get("base_url") or env.get("LDR_LLM_OPENAI_ENDPOINT_URL")
+    if provider == "openai-endpoint" and not base_url:
+        raise ConfigError(
+            "provider 'openai-endpoint' needs --base-url (e.g. http://localhost:8080/v1) "
+            "or LDR_LLM_OPENAI_ENDPOINT_URL."
+        )
+
+    return Settings(
+        provider=provider,
+        model=model,
+        api_key=api_key,
+        search_engine=search_engine,
+        stealth_mode=stealth_mode,
+        depth=depth,
+        respect_robots=bool(cli.get("respect_robots", False)),
+        out=cli.get("out"),
+        proxy=cli.get("proxy"),
+        searxng_url=searxng_url,
+        base_url=base_url,
+    )

deepcloak/evidence.py

@@ -0,0 +1,67 @@
+"""Evidence Records — the per-URL facts captured during a research run.
+
+Slice 3 defines the record and a collector. Slice 4 adds the report badge and
+the JSON sidecar rendering on top of the same data.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+
+__all__ = ["EvidenceRecord", "EvidenceLog"]
+
+
+@dataclass(frozen=True)
+class EvidenceRecord:
+    url: str
+    bot_wall: str | None  # detected Bot Wall kind, or None
+    escalated: bool  # did we switch plain -> Stealth Fetch?
+    bypassed: bool  # did the Stealth Fetch succeed after Escalation?
+    plain_status: int | None
+    elapsed_ms: int
+    signal: str | None = None  # human-readable reason
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class EvidenceLog:
+    records: list[EvidenceRecord] = field(default_factory=list)
+
+    def add(self, record: EvidenceRecord) -> None:
+        self.records.append(record)
+
+    def summary(self) -> dict:
+        walls: dict[str, int] = {}
+        escalated = bypassed = 0
+        for r in self.records:
+            escalated += int(r.escalated)
+            bypassed += int(r.bypassed)
+            if r.bot_wall:
+                walls[r.bot_wall] = walls.get(r.bot_wall, 0) + 1
+        return {
+            "total": len(self.records),
+            "escalated": escalated,
+            "bypassed": bypassed,
+            "walls": walls,
+        }
+
+    def badge(self) -> str:
+        """Markdown section appended to the report. Empty when nothing was bypassed."""
+        s = self.summary()
+        if not s["bypassed"]:
+            return ""
+        plural = "s" if s["bypassed"] != 1 else ""
+        lines = [f"## 🛡️ Bypassed {s['bypassed']} bot-walled source{plural}"]
+        if s["walls"]:
+            parts = ", ".join(f"{k} ×{v}" for k, v in sorted(s["walls"].items()))
+            lines += ["", f"Bot Walls encountered — {parts}."]
+        return "\n".join(lines)
+
+    def to_json(self, indent: int = 2) -> str:
+        return json.dumps(
+            {"summary": self.summary(), "records": [r.as_dict() for r in self.records]},
+            indent=indent,
+        )

deepcloak/fetch_router.py

@@ -0,0 +1,109 @@
+"""The Escalation policy: plain fetch first, Stealth Fetch on a detected Bot Wall.
+
+Deep module. ``fetch()`` takes injectable ``plain_fetch`` / ``stealth_fetch``
+callables so the policy is fully testable with fakes — no network, no browser.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from .bot_wall_detector import BotWall, from_response
+from .evidence import EvidenceRecord
+
+__all__ = ["FetchResult", "fetch"]
+
+PlainFetch = Callable[[str], Any]
+StealthFetch = Callable[[str], str]
+Detector = Callable[[Any], "BotWall | None"]
+RobotsOk = Callable[[str], bool]
+
+
+@dataclass
+class FetchResult:
+    content: str | None
+    evidence: EvidenceRecord
+
+
+def fetch(
+    url: str,
+    *,
+    mode: str = "auto",
+    plain_fetch: PlainFetch,
+    stealth_fetch: StealthFetch,
+    detector: Detector = from_response,
+    respect_robots: bool = False,
+    robots_ok: RobotsOk | None = None,
+) -> FetchResult:
+    start = time.monotonic()
+
+    def ms() -> int:
+        return int((time.monotonic() - start) * 1000)
+
+    def record(**kw) -> EvidenceRecord:
+        kw.setdefault("plain_status", None)
+        return EvidenceRecord(url=url, elapsed_ms=ms(), **kw)
+
+    if respect_robots and robots_ok is not None and not robots_ok(url):
+        return FetchResult(
+            None,
+            record(bot_wall=None, escalated=False, bypassed=False,
+                   signal="skipped: robots.txt disallow"),
+        )
+
+    if mode == "always":
+        try:
+            return FetchResult(
+                stealth_fetch(url),
+                record(bot_wall="forced", escalated=True, bypassed=True,
+                       signal="stealth fetch (mode=always)"),
+            )
+        except Exception as exc:
+            return FetchResult(
+                None,
+                record(bot_wall="forced", escalated=True, bypassed=False,
+                       signal=f"stealth failed: {exc}"),
+            )
+
+    # mode "auto" or "off": try plain first.
+    plain_status: int | None = None
+    plain_content: str | None = None
+    wall: BotWall | None = None
+    try:
+        resp = plain_fetch(url)
+        plain_status = getattr(resp, "status_code", None)
+        plain_content = getattr(resp, "text", None)
+        wall = detector(resp)
+    except Exception as exc:
+        wall = BotWall("blocked", f"plain fetch failed: {exc}")
+
+    if mode == "off":
+        return FetchResult(
+            plain_content,
+            record(bot_wall=wall.kind if wall else None, escalated=False, bypassed=False,
+                   plain_status=plain_status, signal=wall.signal if wall else "plain ok"),
+        )
+
+    # mode "auto"
+    if wall is None:
+        return FetchResult(
+            plain_content,
+            record(bot_wall=None, escalated=False, bypassed=False,
+                   plain_status=plain_status, signal="plain ok, no wall"),
+        )
+
+    try:
+        return FetchResult(
+            stealth_fetch(url),
+            record(bot_wall=wall.kind, escalated=True, bypassed=True, plain_status=plain_status,
+                   signal=f"bypassed {wall.kind}: {wall.signal}"),
+        )
+    except Exception as exc:
+        return FetchResult(
+            plain_content,
+            record(bot_wall=wall.kind, escalated=True, bypassed=False, plain_status=plain_status,
+                   signal=f"escalation failed: {exc}"),
+        )

deepcloak/ldr_shim.py

@@ -0,0 +1,115 @@
+"""Install the Stealth Fetch into local-deep-research (ADR-0001).
+
+We override the narrowest seam — ``AutoHTMLDownloader._fetch_html``, the method
+that returns a page's raw HTML — so every HTML fetch in LDR's pipeline runs
+through ``fetch_router`` (plain → Escalate → Stealth Fetch) and records an
+Evidence Record. LDR's own text extraction (justext) still runs on the HTML we
+return, so we reuse it rather than reimplementing it.
+
+The seam is an internal LDR symbol, so the LDR version is pinned (==) and the
+seam must be re-verified on upgrade.
+"""
+
+from __future__ import annotations
+
+from functools import partial
+from typing import Any
+from urllib.parse import urlparse
+from urllib.robotparser import RobotFileParser
+
+from .evidence import EvidenceLog
+from .fetch_router import fetch
+from .stealth_downloader import plain_get, stealth_get
+
+__all__ = ["install", "uninstall", "default_robots_ok", "make_fetch_html"]
+
+
+def default_robots_ok(url: str) -> bool:
+    """Best-effort robots.txt check; on any error, allow (fail-open)."""
+    try:
+        parts = urlparse(url)
+        rp = RobotFileParser()
+        rp.set_url(f"{parts.scheme}://{parts.netloc}/robots.txt")
+        rp.read()
+        return rp.can_fetch("*", url)
+    except Exception:
+        return True
+
+
+def _load_ldr_downloader() -> type:
+    from local_deep_research.research_library.downloaders.playwright_html import (  # type: ignore
+        AutoHTMLDownloader,
+    )
+
+    return AutoHTMLDownloader
+
+
+def make_fetch_html(
+    *, mode, respect_robots, evidence_log, plain_fetch, stealth_fetch, robots_ok, on_event=None
+):
+    # LDR may call _fetch_html more than once per URL (download / download_with_result).
+    # Cache per run so we Stealth Fetch once and record exactly one Evidence Record.
+    cache: dict[str, str | None] = {}
+
+    def _fetch_html(self, url: str) -> str | None:
+        if url in cache:
+            return cache[url]
+        result = fetch(
+            url,
+            mode=mode,
+            plain_fetch=plain_fetch,
+            stealth_fetch=stealth_fetch,
+            respect_robots=respect_robots,
+            robots_ok=robots_ok,
+        )
+        evidence_log.add(result.evidence)
+        if on_event is not None:
+            on_event(result.evidence)
+        cache[url] = result.content
+        return result.content
+
+    return _fetch_html
+
+
+def install(
+    *,
+    evidence_log: EvidenceLog,
+    mode: str = "auto",
+    respect_robots: bool = False,
+    proxy: str | None = None,
+    target_cls: type | None = None,
+    plain_fetch: Any = plain_get,
+    stealth_fetch: Any = None,
+    robots_ok: Any = None,
+    on_event: Any = None,
+) -> type:
+    """Patch LDR's HTML downloader to route through DeepCloak. Returns the class."""
+    cls = target_cls or _load_ldr_downloader()
+    if stealth_fetch is None:
+        stealth_fetch = partial(stealth_get, proxy=proxy)
+    if respect_robots and robots_ok is None:
+        robots_ok = default_robots_ok
+
+    if not hasattr(cls, "_deepcloak_orig_fetch_html"):
+        cls._deepcloak_orig_fetch_html = getattr(cls, "_fetch_html", None)
+    cls._fetch_html = make_fetch_html(
+        mode=mode,
+        respect_robots=respect_robots,
+        evidence_log=evidence_log,
+        plain_fetch=plain_fetch,
+        stealth_fetch=stealth_fetch,
+        robots_ok=robots_ok,
+        on_event=on_event,
+    )
+    return cls
+
+
+def uninstall(cls: type) -> None:
+    """Restore the original ``_fetch_html`` (used in tests / teardown)."""
+    orig = getattr(cls, "_deepcloak_orig_fetch_html", None)
+    if orig is not None:
+        cls._fetch_html = orig
+    elif hasattr(cls, "_fetch_html"):
+        delattr(cls, "_fetch_html")
+    if hasattr(cls, "_deepcloak_orig_fetch_html"):
+        delattr(cls, "_deepcloak_orig_fetch_html")

deepcloak/mcp_server.py

@@ -0,0 +1,54 @@
+"""DeepCloak MCP server.
+
+Its own entry point (not LDR's ldr-mcp) so the in-process stealth shim applies
+and every research call produces a Bypass + Evidence. Tool bodies are plain
+functions so they're testable without the MCP runtime installed.
+"""
+
+from __future__ import annotations
+
+import itertools
+
+__all__ = ["tool_deep_research", "tool_quick_summary", "tool_get_evidence", "build_server", "serve"]
+
+_RUNS: dict[str, str] = {}
+_COUNTER = itertools.count(1)
+
+
+def tool_deep_research(query: str, depth: str = "detailed") -> str:
+    """Run a Deep Research with stealth fetch and return the cited report."""
+    from .research_core import research
+
+    result = research(query, cli={"depth": depth})
+    run_id = str(next(_COUNTER))
+    _RUNS[run_id] = result.evidence_json
+    _RUNS["last"] = result.evidence_json
+    return result.report
+
+
+def tool_quick_summary(query: str) -> str:
+    """Fast, shallow answer for a query."""
+    return tool_deep_research(query, depth="quick")
+
+
+def tool_get_evidence(run_id: str = "last") -> str:
+    """Return the Evidence Records (JSON) of a prior run; 'last' for the latest."""
+    return _RUNS.get(run_id, "{}")
+
+
+def build_server():
+    """Build the FastMCP server. Requires the optional `mcp` dependency."""
+    try:
+        from mcp.server.fastmcp import FastMCP
+    except ImportError as exc:  # pragma: no cover
+        raise RuntimeError("The MCP server needs `pip install deepcloak[mcp]`.") from exc
+
+    server = FastMCP("deepcloak")
+    server.tool(name="deep_research")(tool_deep_research)
+    server.tool(name="quick_summary")(tool_quick_summary)
+    server.tool(name="get_evidence")(tool_get_evidence)
+    return server
+
+
+def serve() -> None:  # pragma: no cover - exercised live, not in unit tests
+    build_server().run()

deepcloak/progress.py

@@ -0,0 +1,36 @@
+"""Human-readable live progress for a research run.
+
+``format_event`` turns one Evidence Record into a single status line; the CLI
+streams these to stderr as they happen so a real run is legible.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from .evidence import EvidenceRecord
+
+__all__ = ["format_event", "stderr_printer"]
+
+
+def _host(url: str) -> str:
+    try:
+        return url.split("/")[2] if "://" in url else url
+    except Exception:
+        return url
+
+
+def format_event(rec: EvidenceRecord) -> str:
+    host = _host(rec.url)
+    ms = f"{rec.elapsed_ms} ms"
+    if rec.bypassed:
+        return f"  🛡️  {host}  🧱 {rec.bot_wall} → ✅ bypassed   {ms}"
+    if rec.escalated:
+        return f"  ⚠️  {host}  🧱 {rec.bot_wall} → escalation failed   {ms}"
+    if rec.bot_wall:
+        return f"  •  {host}  🧱 {rec.bot_wall} (kept plain)   {ms}"
+    return f"  ✓  {host}  open page   {ms}"
+
+
+def stderr_printer(rec: EvidenceRecord) -> None:
+    print(format_event(rec), file=sys.stderr, flush=True)

deepcloak/research_core.py

@@ -0,0 +1,141 @@
+"""The single entry point every surface (CLI, MCP, skill) goes through.
+
+It resolves settings, applies the LDR environment, runs the research loop, and
+attaches Evidence Records. In slice 1 this is the plain path; the stealth shim
+is installed here from slice 3 onward.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from . import ldr_shim
+from .config import Settings, resolve
+from .evidence import EvidenceLog
+
+__all__ = ["Result", "research"]
+
+# Maps our depth to the LDR api.research_functions callable name.
+_LDR_FUNCTION = {
+    "quick": "quick_summary",
+    "detailed": "detailed_research",
+    "report": "generate_report",
+}
+
+
+@dataclass
+class Result:
+    report: str
+    settings: Settings
+    evidence: list[dict[str, Any]] = field(default_factory=list)
+    evidence_json: str = "{}"
+
+
+def _run_ldr(
+    query: str,
+    settings: Settings,
+    evidence_log: Any = None,
+    on_event: Any = None,
+    rf: Any | None = None,
+) -> str:
+    """Call local-deep-research's programmatic API. Imported lazily so the
+    package (and its pure modules) load without the heavy upstream installed.
+    ``rf`` may be injected in tests."""
+    fn_kwargs: dict[str, Any] = {}
+    if rf is None:
+        from local_deep_research.api import research_functions as rf  # type: ignore
+
+        overrides = settings.to_ldr_overrides()
+
+        # Real integration: hand LDR a StealthRetriever so it synthesises over
+        # full pages we fetched through the stealth path (Bypassing walls),
+        # instead of search snippets. This is what makes a research run actually
+        # read bot-walled sources.
+        if settings.searxng_url:
+            try:
+                from .retriever import build_stealth_retriever
+
+                fn_kwargs["retrievers"] = {
+                    "stealth": build_stealth_retriever(
+                        searxng_url=settings.searxng_url,
+                        mode=settings.stealth_mode,
+                        evidence_log=evidence_log,
+                        on_event=on_event,
+                        respect_robots=settings.respect_robots,
+                        proxy=settings.proxy,
+                    )
+                }
+                overrides["search.tool"] = "stealth"
+            except Exception:
+                pass
+
+        try:
+            from local_deep_research.api.settings_utils import (  # type: ignore
+                create_settings_snapshot,
+            )
+
+            fn_kwargs["settings_snapshot"] = create_settings_snapshot(overrides=overrides)
+        except Exception:
+            pass
+
+    fn = getattr(rf, _LDR_FUNCTION[settings.depth])
+    result = fn(query, **fn_kwargs)
+    # LDR functions return either a string or a dict with a summary/report field.
+    if isinstance(result, Mapping):
+        return str(result.get("summary") or result.get("report") or result)
+    return str(result)
+
+
+def research(
+    query: str,
+    cli: Mapping | None = None,
+    env: Mapping | None = None,
+    verbose: bool = False,
+) -> Result:
+    """Run a Deep Research and return the report plus Evidence Records.
+
+    ``verbose=True`` streams live progress to stderr (used by the CLI)."""
+    import sys
+
+    settings = resolve(cli or {}, env if env is not None else os.environ)
+    os.environ.update(settings.to_ldr_env())
+
+    on_event = None
+    if verbose:
+        from .progress import stderr_printer as on_event
+
+        print(f"🔎 researching: {query}", file=sys.stderr, flush=True)
+
+    evidence_log = EvidenceLog()
+    try:
+        ldr_shim.install(
+            evidence_log=evidence_log,
+            mode=settings.stealth_mode,
+            respect_robots=settings.respect_robots,
+            proxy=settings.proxy,
+            on_event=on_event,
+        )
+    except Exception:
+        # LDR not importable yet / seam moved — proceed without stealth (degraded).
+        pass
+
+    report = _run_ldr(query, settings, evidence_log=evidence_log, on_event=on_event)
+    badge = evidence_log.badge()
+    if badge:
+        report = f"{report}\n\n{badge}"
+    if verbose:
+        s = evidence_log.summary()
+        print(
+            f"✅ done — {s['total']} sources, {s['bypassed']} bot wall(s) bypassed",
+            file=sys.stderr,
+            flush=True,
+        )
+    return Result(
+        report=report,
+        settings=settings,
+        evidence=[r.as_dict() for r in evidence_log.records],
+        evidence_json=evidence_log.to_json(),
+    )

deepcloak/retriever.py

@@ -0,0 +1,118 @@
+"""StealthRetriever — the real integration seam.
+
+A LangChain retriever that DeepCloak hands to local-deep-research's
+``retrievers=`` API. For each search hit it fetches the *full page* through the
+stealth ``fetch_router`` (plain → Escalate → Stealth Fetch), so the research
+loop synthesises over Bypassed content — not snippets. Every fetch is recorded
+as an Evidence Record.
+
+LangChain is only imported here (it ships with local-deep-research), so the
+pure modules and CI stay free of it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .fetch_router import fetch
+from .stealth_downloader import plain_get, stealth_get
+
+__all__ = ["build_stealth_retriever", "searxng_search"]
+
+
+def searxng_search(base_url: str, query: str, max_results: int = 8) -> list[dict]:
+    """Query a SearXNG instance and return [{url, title}] hits."""
+    import requests
+
+    r = requests.get(
+        f"{base_url.rstrip('/')}/search",
+        params={"q": query, "format": "json"},
+        timeout=20,
+        headers={"User-Agent": "deepcloak"},
+    )
+    r.raise_for_status()
+    out: list[dict] = []
+    for item in (r.json().get("results") or [])[:max_results]:
+        url = item.get("url")
+        if url:
+            out.append({"url": url, "title": item.get("title", "")})
+    return out
+
+
+def _cap_content(text: str, max_chars: int | None) -> str:
+    """Cap a document's text so many Bypassed pages still fit a model's context.
+
+    A small local model (e.g. a 16k-context llama-server) overflows when the
+    retriever feeds full pages into the synthesis prompt, so the report step
+    never runs. ``max_chars`` of ``None``/``0`` disables the cap.
+    """
+    if max_chars and len(text) > max_chars:
+        return text[:max_chars]
+    return text
+
+
+def _extract_text(html: str) -> str:
+    """Best-effort readable-text extraction (reuses LDR's extractor if present)."""
+    try:
+        from local_deep_research.research_library.downloaders.extraction import (  # type: ignore
+            extract_content,
+        )
+
+        text = extract_content(html, language="English", min_length=100)
+        if text:
+            return text
+    except Exception:
+        pass
+    return html
+
+
+def build_stealth_retriever(
+    *,
+    searxng_url: str,
+    mode: str = "auto",
+    max_results: int = 8,
+    max_chars: int = 2000,
+    evidence_log: Any = None,
+    on_event: Any = None,
+    respect_robots: bool = False,
+    robots_ok: Any = None,
+    proxy: str | None = None,
+):
+    """Construct a LangChain BaseRetriever backed by the stealth fetch path."""
+    from functools import partial
+
+    from langchain_core.retrievers import BaseRetriever, Document  # type: ignore
+
+    stealth_fetch = partial(stealth_get, proxy=proxy)
+
+    class StealthRetriever(BaseRetriever):
+        model_config = {"arbitrary_types_allowed": True}
+
+        def _get_relevant_documents(self, query: str, *, run_manager=None):  # noqa: D401
+            docs = []
+            for hit in searxng_search(searxng_url, query, max_results):
+                url = hit["url"]
+                result = fetch(
+                    url,
+                    mode=mode,
+                    plain_fetch=plain_get,
+                    stealth_fetch=stealth_fetch,
+                    respect_robots=respect_robots,
+                    robots_ok=robots_ok,
+                )
+                if evidence_log is not None:
+                    evidence_log.add(result.evidence)
+                if on_event is not None:
+                    on_event(result.evidence)
+                if result.content:
+                    docs.append(
+                        Document(
+                            page_content=_cap_content(
+                                _extract_text(result.content), max_chars
+                            ),
+                            metadata={"url": url, "title": hit.get("title", "")},
+                        )
+                    )
+            return docs
+
+    return StealthRetriever()

deepcloak/setup.py

@@ -0,0 +1,77 @@
+"""`deepcloak setup` — download the stealth browser and check the environment."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from collections.abc import Mapping
+
+__all__ = ["run_setup", "check_env", "install_browser"]
+
+_KEY_VARS = ("OPENAI_API_KEY", "ANTHROPIC_API_KEY", "GEMINI_API_KEY", "OPENROUTER_API_KEY")
+
+
+def check_env(env: Mapping[str, str] | None = None) -> list[str]:
+    """Return a list of warnings about the environment (empty == all good)."""
+    env = os.environ if env is None else env
+    warnings: list[str] = []
+    if not any(env.get(k) for k in _KEY_VARS):
+        warnings.append(
+            "No LLM API key found — set one of "
+            + ", ".join(_KEY_VARS)
+            + " (or use --provider ollama for a local model)."
+        )
+    return warnings
+
+
+def _playwright_install() -> bool:
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "playwright", "install", "chromium"],
+            check=True,
+            capture_output=True,
+        )
+        return True
+    except Exception:
+        return False
+
+
+_UNSET = object()
+
+
+def install_browser(cb: object = _UNSET) -> tuple[bool, str]:
+    """Best-effort: ensure the stealth browser binary is available.
+
+    ``cb`` is the cloakbrowser module; pass ``None`` to simulate it missing.
+    """
+    if cb is _UNSET:
+        try:
+            import cloakbrowser as cb  # type: ignore
+        except ImportError:
+            cb = None
+    if cb is None:
+        return False, "cloakbrowser is not installed — run `pip install deepcloak`."
+
+    # cloakbrowser manages its own stealth Chromium via ensure_binary()/download().
+    for fname in ("ensure_binary", "download", "install"):
+        fn = getattr(cb, fname, None)
+        if callable(fn):
+            try:
+                path = fn()
+                where = f" ({path})" if isinstance(path, str) else ""
+                return True, f"Stealth browser ready via cloakbrowser.{fname}(){where}."
+            except Exception:
+                continue
+    if _playwright_install():
+        return True, "Stealth browser (Chromium) installed via Playwright."
+    return True, "cloakbrowser present; could not confirm the browser download — try manually."
+
+
+def run_setup(cb: object = _UNSET) -> int:
+    ok, msg = install_browser(cb)
+    print(msg)
+    for warning in check_env():
+        print(f"warning: {warning}")
+    print("DeepCloak is ready." if ok else "Setup incomplete — see the message above.")
+    return 0 if ok else 1

deepcloak/stealth_downloader.py

@@ -0,0 +1,47 @@
+"""Concrete plain and stealth fetchers used by the shim.
+
+- ``plain_get`` is an ordinary HTTP GET (cheap, tried first).
+- ``stealth_get`` drives CloakBrowser's stealth Chromium to Bypass a Bot Wall.
+
+Both lazy-import their heavy dependency so the package imports without it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+__all__ = ["plain_get", "stealth_get"]
+
+_UA = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/126.0 Safari/537.36"
+)
+
+
+def plain_get(url: str, timeout: int = 20) -> Any:
+    """Plain HTTP GET, returning a requests.Response."""
+    try:
+        import requests
+    except ImportError as exc:  # pragma: no cover - requests is a hard dep
+        raise RuntimeError("requests not installed") from exc
+    return requests.get(url, timeout=timeout, headers={"User-Agent": _UA})
+
+
+def stealth_get(url: str, proxy: str | None = None, wait_ms: int = 3000) -> str:
+    """Fetch a page through CloakBrowser's stealth Chromium and return its HTML."""
+    try:
+        import cloakbrowser
+    except ImportError as exc:
+        raise RuntimeError(
+            "cloakbrowser is not installed or the stealth browser is missing — "
+            "run `deepcloak setup`."
+        ) from exc
+
+    kwargs: dict[str, Any] = {}
+    if proxy:
+        kwargs["proxy"] = proxy
+    with cloakbrowser.launch_context(**kwargs) as ctx:
+        page = ctx.new_page()
+        page.goto(url, wait_until="domcontentloaded", timeout=60000)
+        page.wait_for_timeout(wait_ms)
+        return page.content()

deepcloak-0.1.0.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: deepcloak
+Version: 0.1.0
+Summary: Local-first deep research agent that reads the whole web — even pages behind Cloudflare, Datadome, Turnstile & reCAPTCHA.
+Project-URL: Homepage, https://github.com/Mrbaeksang/deepcloak
+Project-URL: Repository, https://github.com/Mrbaeksang/deepcloak
+Project-URL: Author, https://baeksang.dev
+Author-email: Mrbaeksang <contact@baeksang.dev>
+License-Expression: MIT
+License-File: LICENSE
+License-File: NOTICE
+Keywords: ai-agent,anti-bot,cloudflare,deep-research,llm,local-first,mcp,rag,stealth,web-scraping
+Requires-Python: >=3.11
+Requires-Dist: cloakbrowser>=0.3.27
+Requires-Dist: local-deep-research==1.6.11
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<h1>🛡️ DeepCloak</h1>
+
+### The deep-research agent that reads the pages others can't.
+
+**Cloudflare · Datadome · Turnstile · reCAPTCHA — it walks straight through them.**
+
+[![CI](https://github.com/Mrbaeksang/deepcloak/actions/workflows/ci.yml/badge.svg)](https://github.com/Mrbaeksang/deepcloak/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-a855f7.svg)](LICENSE)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue.svg)](pyproject.toml)
+[![MCP native](https://img.shields.io/badge/MCP-native-22d3ee.svg)](#-use-it-from-an-ai-agent)
+[![PRs welcome](https://img.shields.io/badge/PRs-welcome-34d399.svg)](CONTRIBUTING.md)
+[![GitHub stars](https://img.shields.io/github/stars/Mrbaeksang/deepcloak?style=social)](https://github.com/Mrbaeksang/deepcloak/stargazers)
+[![Watch on YouTube](https://img.shields.io/badge/▶_demo-YouTube-FF0000.svg)](https://youtu.be/p5ompjDLzaI)
+
+**English** · [한국어](README.ko.md) · [简体中文](README.zh-CN.md)
+
+### [▶ Live demo — deepcloak.vercel.app](https://deepcloak.vercel.app)  ·  [▶ Watch on YouTube](https://youtu.be/p5ompjDLzaI)
+
+[![DeepCloak running: it detects a Cloudflare Turnstile, escalates, and bypasses it — then writes a cited report](docs/media/demo.gif)](https://youtu.be/p5ompjDLzaI)
+
+</div>
+
+---
+
+## The problem
+
+You ask a research tool a question. Half the best sources sit behind a **Bot Wall** — Cloudflare, Datadome, a Turnstile, a reCAPTCHA. Every other tool gets a `403`, silently drops those pages, and hands you a thinner report. **You never even learn what it missed.**
+
+## What DeepCloak does
+
+When a plain fetch hits a Bot Wall, DeepCloak **Escalates** that one URL to a **Stealth Fetch** and **Bypasses** the wall — recovering the content other agents abandon. Then it tells you, at the bottom of every report, exactly how many walls it broke through.
+
+It's a thin, local-first orchestrator over two great projects: [`local-deep-research`](https://github.com/LearningCircuit/local-deep-research) (the research loop) and [`CloakBrowser`](https://github.com/CloakHQ/CloakBrowser) (the stealth browser). Use it as a **CLI**, an **MCP server**, or a **Claude skill**. MIT.
+
+## 🌑 Why we built this
+
+The open web is quietly closing. More of the best writing now sits behind a bot check, and AI research agents — the tools we increasingly trust to read the web *for us* — go blind at exactly those doors, without ever saying so. A report that silently skips every walled source isn't neutral; it's wrong in a way you can't see.
+
+DeepCloak's stance is simple: **your agent should be able to read what a person with a browser can read** — and it should be honest about how it got there. So it Bypasses the wall when it has to, keeps everything local (no query or page leaves your machine), and prints an Evidence Record of every wall it crossed. Capability *and* transparency, MIT-licensed, no lock-in.
+
+## ✨ Why it's different
+
+|  | Plain deep research | **DeepCloak** |
+| --- | :---: | :---: |
+| Reads the open web | ✅ | ✅ |
+| Reads Cloudflare / Datadome / Turnstile / reCAPTCHA pages | ❌ *dropped silently* | ✅ **Bypassed** |
+| Tells you which sources were walled | ❌ | ✅ Evidence Record |
+| Local-first (no API key required) | ✅ | ✅ |
+| Fast on open pages | — | ✅ *plain-first, stealth only when needed* |
+
+> **Verified live — not mocked.** The clip above is an **unedited screen recording** (captured with `ffmpeg`, no compositing) of a real `deepcloak` run against a **local LLM (Qwen) + SearXNG — no API key**. It Escalates on each Bot Wall and **Bypasses 8 Cloudflare/Turnstile walls** in one pass, then writes a cited report. Full clip: [`docs/media/demo-real.mp4`](docs/media/demo-real.mp4); a raw asciinema session is also kept at [`docs/media/demo.cast`](docs/media/demo.cast). Wall counts vary per run (8–20) because the open web does.
+
+## 🚀 Quickstart
+
+```bash
+pip install deepcloak
+deepcloak setup                       # one-time: downloads the stealth browser
+export OPENAI_API_KEY=...             # or ANTHROPIC_API_KEY / GEMINI_API_KEY — or --provider ollama
+deepcloak "How does Cloudflare Turnstile detect bots?" --depth detailed --out report.md
+```
+
+You get a cited `report.md` ending with a `🛡️ Bypassed N bot-walled sources` section, plus a `report.md.evidence.json` sidecar.
+
+## 🧠 How it works
+
+```
+search (DuckDuckGo, no setup) ─▶ candidate URLs
+        │
+        ▼  for each page:
+   plain fetch ─▶ Bot Wall detected? ──no──▶ use it (fast)
+                        │ yes
+                        ▼
+                  Escalate ─▶ Stealth Fetch (CloakBrowser) ─▶ Bypass
+        │
+        ▼
+research loop (local-deep-research) ─▶ cited report + Evidence Records
+```
+
+Stealth is heavy, so DeepCloak tries a cheap plain fetch first and only launches the stealth browser when it actually detects a Bot Wall (`--stealth auto`, the default). Use `--depth detailed`/`report` to fetch full pages where Bypasses happen.
+
+## 🤖 Connect it to your agent (MCP)
+
+DeepCloak runs as a stdio **MCP server** exposing `deep_research(query, depth)`, `quick_summary(query)`, and `get_evidence(run_id)`.
+
+**Claude Code** — add to your project's `.mcp.json` (an example ships in this repo):
+
+```json
+{ "mcpServers": { "deepcloak": { "command": "deepcloak", "args": ["mcp"] } } }
+```
+
+**Codex** — add to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.deepcloak]
+command = "deepcloak"
+args = ["mcp"]
+```
+
+Then your agent can call `deep_research` and read bot-walled sources directly. Prefer a slash-style skill? Drop [`skill/SKILL.md`](skill/SKILL.md) into `~/.claude/skills/deepcloak/`.
+
+## ⚙️ Configuration
+
+| Flag | Default | Notes |
+| --- | --- | --- |
+| `--depth` | `detailed` | `quick` / `detailed` / `report` |
+| `--engine` | `duckduckgo` | `searxng` / `auto` |
+| `--stealth` | `auto` | `always` / `off` |
+| `--provider` / `--model` | auto-detected | `OPENAI` → `ANTHROPIC` → `GEMINI`, or `ollama` |
+| `--respect-robots` | off | honor robots.txt |
+| `--proxy` | — | SOCKS5 for the Stealth Fetch |
+
+## ⚠️ Responsible use
+
+DeepCloak Bypasses bot-detection. **You are responsible for having the right to access whatever you fetch.** robots.txt is **ignored by default**; pass `--respect-robots` to honor it ([ADR-0002](docs/adr/0002-ignore-robots-by-default.md)). Don't use it to violate sites' terms or the law.
+
+## 🛠️ Built on
+
+[`local-deep-research`](https://github.com/LearningCircuit/local-deep-research) (MIT) + [`CloakBrowser`](https://github.com/CloakHQ/CloakBrowser) (MIT), via pip — no vendored code. Domain glossary in [CONTEXT.md](CONTEXT.md); design decisions in [docs/adr/](docs/adr/); contributing guide in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## 📄 License
+
+MIT — see [LICENSE](LICENSE) and [NOTICE](NOTICE).
+
+<div align="center">
+
+**If DeepCloak read a page your last tool gave up on, drop a ⭐ — it helps others find it.**
+
+Built by **[Mrbaeksang](https://baeksang.dev)** · [baeksang.dev](https://baeksang.dev) · [contact@baeksang.dev](mailto:contact@baeksang.dev)
+
+[![Star History Chart](https://api.star-history.com/svg?repos=Mrbaeksang/deepcloak&type=Date)](https://star-history.com/#Mrbaeksang/deepcloak&Date)
+
+</div>

deepcloak-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+deepcloak/__init__.py,sha256=98KQ1ijIK4a4lXI_-ATlcOBosgpYgFKrHMbd0ounEd8,98
+deepcloak/bot_wall_detector.py,sha256=TPR-ME_UZkixTzJ6eM_yB5_8RBWD_WTkV4mEkqqGDiI,2610
+deepcloak/cli.py,sha256=dP35Fjc1rG7OjMxCrYh25NqTzJs40TsDnwhZiOfCvXw,3141
+deepcloak/config.py,sha256=t4tfmej-g85oPZ3DQ2Tux88-G_7BoT6j1SRkBtYClfk,6288
+deepcloak/evidence.py,sha256=9AkA--Jd5yKr8p_S2e8qRebZevgvaz2w39tdfoWEWDI,2156
+deepcloak/fetch_router.py,sha256=eIohEJI_rIWbMfKYJ9geGWzvIDt8AsJHj_fphEDAY80,3431
+deepcloak/ldr_shim.py,sha256=hY10rM3iWUA1hfG2lPED-rMYy61WIE__5EuMdQF_wMo,3774
+deepcloak/mcp_server.py,sha256=9H-A1xFQrtoZ-flvu2gLvn6fVweBsyH35k9xHuEpfXY,1782
+deepcloak/progress.py,sha256=VJhz6xND3H7cJpSG0fxDaJZbX_-tP8ofaiKYSNiaNqg,1034
+deepcloak/research_core.py,sha256=Q3uRAyiAOuTcCuzbNVnQ_RRIhmLo3jG0HtsiQWDeVC8,4521
+deepcloak/retriever.py,sha256=s-dTGREI5kwYZlCKJaENulUHwPTAHbX4xRb3ALspXNE,3984
+deepcloak/setup.py,sha256=y68jryW4BOhh8ktpOw6xhYUOFyhu6arzvPQGj6B70AM,2522
+deepcloak/stealth_downloader.py,sha256=7r36ZBPsD-YqgzIe3-sInx-PFbHpsW0D_BQNE3cRt1s,1571
+deepcloak-0.1.0.dist-info/METADATA,sha256=vGuhfPXWD_Pwy1eX7locdvSgH9UGLuuJIpeiS2I5KHg,8234
+deepcloak-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+deepcloak-0.1.0.dist-info/entry_points.txt,sha256=x1i7EWsSQXO463HmNKmzJbWhB6Q5t9hNtBtazdl7y5Q,49
+deepcloak-0.1.0.dist-info/licenses/LICENSE,sha256=8m17jZTiuCB6Xv_5GVsK6SM86zpyFX31eoXXghTI03c,1067
+deepcloak-0.1.0.dist-info/licenses/NOTICE,sha256=WzWf4iJunAFVZ15H5nNxhqcYuy85ng0qH_Jsaayw24M,897
+deepcloak-0.1.0.dist-info/RECORD,,

deepcloak-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

deepcloak-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deepcloak = deepcloak.cli:main

deepcloak-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mrbaeksang
+
+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.

deepcloak-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,21 @@
+DeepCloak
+Copyright (c) 2026 Mrbaeksang
+
+This product depends on, and is built around, the following open-source projects.
+DeepCloak does not vendor their code; it depends on them via pip.
+
+-------------------------------------------------------------------------------
+local-deep-research
+  Homepage: https://github.com/LearningCircuit/local-deep-research
+  License:  MIT
+  Role:     the iterative multi-source Deep Research loop.
+
+-------------------------------------------------------------------------------
+CloakBrowser
+  Homepage: https://github.com/CloakHQ/CloakBrowser
+  License:  MIT
+  Role:     the stealth Chromium that performs the Stealth Fetch / Bypass.
+
+-------------------------------------------------------------------------------
+Both are MIT-licensed; their copyright and permission notices apply to their
+respective code. See each project's repository for full license text.