agentsentinel-cli 0.7.1__tar.gz → 0.7.3__tar.gz

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentsentinel-cli
-Version: 0.7.1
+Version: 0.7.3
 Summary: Agentic security CLI — AI analyst with memory, supply chain audit, MCP audit, red-team probing, and agent discovery
 Project-URL: Homepage, https://github.com/jaydenaung/agentsentinel-cli
 Project-URL: Repository, https://github.com/jaydenaung/agentsentinel-cli

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/cli.py

@@ -123,52 +123,82 @@ def _enrich_from_platform(agents, scores_map, connect_url, api_key):
 
 @main.command()
 @click.option("--process/--no-process", default=True, show_default=True,
-              help="Scan running processes for LLM API usage.")
+              help="Scan running processes for MCP servers and agent signals.")
 @click.option("--network/--no-network", default=True, show_default=True,
-              help="Probe local ports for MCP servers and agent APIs.")
+              help="Probe local ports — confirmed via MCP protocol handshake.")
 @click.option("--docker/--no-docker", default=False, show_default=True,
-              help="Inspect running Docker containers.")
-@click.option("--path", "scan_path", default=None, type=click.Path(exists=True, path_type=Path),
-              metavar="DIR", help="Scan a directory for agent source files.")
+              help="Inspect running Docker containers for MCP/agent patterns.")
+@click.option("--host", default=None, metavar="IP",
+              help="Scan a single host, e.g. 10.0.1.45.")
 @click.option("--subnet", default=None, metavar="CIDR",
-              help="Scan a CIDR subnet for AI agent endpoints, e.g. 10.0.0.0/24.")
+              help="Scan a CIDR subnet for MCP servers, e.g. 10.0.0.0/24.")
 @click.option("--ports", default=None, metavar="RANGE",
-              help="Custom port range for network scan, e.g. 8000-9001. Defaults to common agent ports.")
+              help="Custom port range, e.g. 8000-9001. Defaults to common MCP/agent ports.")
+@click.option("--auth-header", "auth_header", default=None, metavar="HEADER",
+              help="HTTP auth header for MCP handshakes, e.g. 'Authorization: Bearer token'.")
 @click.option("--format", "fmt", type=click.Choice(["text", "json"]), default="text",
               help="Output format.")
 @click.option("--verbose", "-v", is_flag=True, default=False,
-              help="Show full details per discovered agent.")
+              help="Show full details per discovered server.")
 def discover(
     process: bool,
     network: bool,
     docker: bool,
-    scan_path: Path | None,
+    host: str | None,
     subnet: str | None,
     ports: str | None,
+    auth_header: str | None,
     fmt: str,
     verbose: bool,
 ) -> None:
-    """Find AI agents running in your environment.
+    """Find MCP servers and AI agent processes in your environment.
 
-    Scans running processes, local network ports, source files, and Docker
-    containers to surface AI agents — including unmonitored ones.
+    Confirms MCP servers via protocol handshake — not just open ports.
 
     \b
     Examples:
-        sentinel discover                        scan processes + network
-        sentinel discover --docker               include Docker containers
-        sentinel discover --path ./agents        scan a source directory
-        sentinel discover --subnet 10.0.0.0/24   scan internal subnet
-        sentinel discover --no-process           network scan only
-        sentinel discover --ports 8000-9001      custom port range
-        sentinel discover --format json          machine-readable output
+        sentinel discover                              local processes + ports
+        sentinel discover --host 10.0.1.45            single remote host
+        sentinel discover --subnet 10.0.0.0/24        full subnet scan
+        sentinel discover --subnet 10.0.0.0/24 \\
+          --auth-header 'Authorization: Bearer token'  scan with credentials
+        sentinel discover --no-process                 network only
+        sentinel discover --docker                     include containers
+        sentinel discover --ports 8000-9001            custom port range
+        sentinel discover --format json                machine-readable output
     """
-    from agentsentinel_cli.discover import run_discovery, as_json as discover_json
+    from agentsentinel_cli.discover import run_discovery, scan_network, as_json as discover_json
     from agentsentinel_cli.discover_report import print_discover_result, print_subnet_progress
 
     # Parse port range
     port_list = _parse_ports(ports) if ports else None
 
+    # Parse auth header
+    extra_headers: dict[str, str] = {}
+    if auth_header:
+        if ":" not in auth_header:
+            console.print("[red]Error:[/red] --auth-header must be 'Header-Name: value' format.")
+            sys.exit(1)
+        key, _, val = auth_header.partition(":")
+        extra_headers[key.strip()] = val.strip()
+
+    # --host: single-host scan — bypass run_discovery and call scan_network directly
+    if host:
+        if fmt == "text":
+            _warn_missing_deps(False, True)
+        agents = scan_network(
+            host=host,
+            ports=port_list,
+            extra_headers=extra_headers or None,
+        )
+        if fmt == "json":
+            click.echo(discover_json(agents))
+            return
+        print_discover_result(agents, vectors=[f"host ({host})"], verbose=verbose)
+        if any(a.risk == "CRITICAL" for a in agents):
+            sys.exit(1)
+        return
+
     # Collect active scan vectors for the header
     vectors = []
     if process:
@@ -177,14 +207,12 @@ def discover(
         vectors.append("network")
     if subnet:
         vectors.append(f"subnet ({subnet})")
-    if scan_path:
-        vectors.append(f"files ({scan_path})")
     if docker:
         vectors.append("docker")
 
     if not vectors:
         console.print("[yellow]No scan vectors selected — use at least one of: "
-                      "--process, --network, --subnet, --path, --docker[/yellow]")
+                      "--process, --network, --host, --subnet, --docker[/yellow]")
         sys.exit(1)
 
     if fmt == "text":
@@ -197,9 +225,9 @@ def discover(
         do_process=process,
         do_network=network,
         do_docker=docker,
-        scan_path=scan_path,
         ports=port_list,
         subnet=subnet,
+        extra_headers=extra_headers or None,
         subnet_progress_cb=progress_cb,
     )
 

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/discover.py

@@ -1,12 +1,11 @@
 """
-sentinel discover — finds AI agents across processes, network, files, and Docker containers.
+sentinel discover — find MCP servers and AI agent processes.
 
 Scan vectors:
-  process   running Python/Node processes making LLM API calls
-  network   open ports serving MCP SSE endpoints or agent APIs
-  subnet    CIDR subnet scan — finds agents across an internal network
-  files     Python source files in a directory containing agent patterns
-  docker    Docker containers with LLM API keys in their environment
+  process   running Python/Node processes serving MCP or calling LLM APIs
+  network   open ports on localhost confirmed as MCP via protocol handshake
+  subnet    CIDR subnet — TCP sweep then MCP handshake on every open port
+  docker    Docker containers with MCP server or LLM agent patterns
 """
 
 from __future__ import annotations
@@ -34,17 +33,19 @@ from agentsentinel_cli.frameworks import (
 
 @dataclasses.dataclass
 class DiscoveredAgent:
-    source: str            # process | network | subnet | file | docker
+    source: str            # process | network | subnet | docker
     name: str              # human-readable name
-    framework: str         # LangChain | OpenAI Agents SDK | MCP | etc.
+    framework: str         # FastMCP | LangChain | AutoGen | etc.
     provider: str          # Anthropic | OpenAI | Google | etc.
     model: str             # claude-sonnet | gpt-4o | etc.  (empty if unknown)
-    location: str          # pid:1234 | 10.0.1.45:8080 | /path/file.py | container:name
+    location: str          # pid:1234 | 10.0.1.45:8080 | container:name
     api_keys: list[str]    # masked keys: ANTHROPIC_API_KEY=sk-ant-...5f3d
     live_connections: list[str]   # LLM API hosts this process is talking to
     risk: str              # CRITICAL | HIGH | MEDIUM | LOW | UNKNOWN
     risk_reason: str       # one-line explanation of the risk level
     next_step: str         # suggested follow-up command
+    tools: list[str] = dataclasses.field(default_factory=list)   # tool names (MCP enumeration)
+    transport: str = ""    # "http" | "sse" | "" (empty for non-MCP)
 
 
 @dataclasses.dataclass
@@ -68,10 +69,6 @@ _DEFAULT_PORTS = [
     11434,                   # Ollama
 ]
 
-_MCP_INDICATOR_PATHS   = ["/sse", "/messages/"]
-_OPENAI_COMPAT_PATHS   = ["/v1/models"]
-_SENTINEL_PATHS        = ["/api/v1/agents", "/health"]
-
 # Subnet scan limits — scanning beyond these sizes is impractical
 _MAX_SUBNET_HOSTS_WARN  = 1024    # /22 — warn but allow
 _MAX_SUBNET_HOSTS_BLOCK = 65536   # /16 — refuse (too slow, too noisy)
@@ -221,8 +218,9 @@ def scan_network(
     host: str = "127.0.0.1",
     ports: list[int] | None = None,
     timeout: float = 0.5,
+    extra_headers: dict[str, str] | None = None,
 ) -> list[DiscoveredAgent]:
-    """Probe a single host's ports for AI agent endpoints."""
+    """Probe a single host's ports — confirms MCP via protocol handshake."""
     if ports is None:
         ports = _DEFAULT_PORTS
 
@@ -230,11 +228,20 @@ def scan_network(
     if not open_ports:
         return []
 
+    # SSE handshake needs much more time than a TCP connect — use a fixed floor
+    # of 8 seconds regardless of the port-sweep timeout.
+    handshake_timeout = max(timeout * 16, 8.0)
+
     found: list[DiscoveredAgent] = []
-    for port in open_ports:
-        agent = _probe_port(host, port, timeout * 4)
-        if agent:
-            found.append(agent)
+    with ThreadPoolExecutor(max_workers=min(10, len(open_ports))) as pool:
+        futures = {
+            pool.submit(_probe_mcp, host, port, handshake_timeout, extra_headers): port
+            for port in open_ports
+        }
+        for future in as_completed(futures):
+            agent = future.result()
+            if agent:
+                found.append(agent)
     return found
 
 
@@ -273,19 +280,24 @@ def scan_subnet(
     cidr: str,
     ports: list[int] | None = None,
     timeout: float = 0.3,
-    on_progress: Optional[Callable[[int, int, str], None]] = None,
+    extra_headers: dict[str, str] | None = None,
+    on_progress: Optional[Callable[[int, int, str, str], None]] = None,
 ) -> tuple[list[DiscoveredAgent], SubnetScanStats]:
-    """Scan every host in a CIDR subnet for AI agent endpoints.
+    """Scan every host in a CIDR subnet for MCP servers.
 
-    Uses a two-phase approach:
-      Phase 1 — parallel TCP connect across all host:port combinations (fast)
-      Phase 2 — HTTP probe on every open port to identify agent type (targeted)
+    Two phases:
+      Phase 1 — parallel TCP connect across all host:port pairs (fast sweep)
+      Phase 2 — MCP protocol handshake on every open port (targeted verification)
+
+    A result in Phase 2 means the MCP initialize exchange completed — not just
+    that a port was open.
 
     Args:
-        cidr:        Network range, e.g. "10.0.0.0/24"
-        ports:       Port list to probe (default: _DEFAULT_PORTS)
-        timeout:     Per-connection TCP timeout in seconds
-        on_progress: Optional callback(completed, total, current_ip) for progress display
+        cidr:         Network range, e.g. "10.0.0.0/24"
+        ports:        Port list to probe (default: _DEFAULT_PORTS)
+        timeout:      Per-connection TCP timeout in seconds
+        extra_headers: HTTP headers for MCP handshake (auth tokens, etc.)
+        on_progress:  Optional callback(completed, total, current_ip, phase)
 
     Returns:
         (agents, stats) tuple
@@ -302,7 +314,7 @@ def scan_subnet(
     if len(hosts) > _MAX_SUBNET_HOSTS_BLOCK:
         raise ValueError(
             f"{cidr} contains {len(hosts):,} hosts. "
-            f"Maximum supported is {_MAX_SUBNET_HOSTS_BLOCK:,} (/{32 - _MAX_SUBNET_HOSTS_BLOCK.bit_length() + 1}). "
+            f"Maximum supported is {_MAX_SUBNET_HOSTS_BLOCK:,}. "
             "Use a smaller subnet or scan individual host ranges."
         )
 
@@ -310,8 +322,7 @@ def scan_subnet(
     total_probes = len(hosts) * len(ports)
     open_targets: list[tuple[str, int]] = []
 
-    # ── Phase 1: parallel TCP connect across all host:port pairs ─────────────
-    # High concurrency — most connections refuse immediately, failures are cheap.
+    # ── Phase 1: parallel TCP connect ────────────────────────────────────────
     completed = 0
     workers = min(250, total_probes)
 
@@ -323,25 +334,36 @@ def scan_subnet(
             return None
 
     tasks = [(h, p) for h in hosts for p in ports]
-    futures = {}
 
     with ThreadPoolExecutor(max_workers=workers) as pool:
-        futures = {pool.submit(check_port, h, p): (h, p) for h, p in tasks}
-        for future in as_completed(futures):
+        futures_p1 = {pool.submit(check_port, h, p): (h, p) for h, p in tasks}
+        for future in as_completed(futures_p1):
             result = future.result()
             if result:
                 open_targets.append(result)
             completed += 1
             if on_progress:
-                host_ip, _ = futures[future]
-                on_progress(completed, total_probes, host_ip)
+                host_ip, _ = futures_p1[future]
+                on_progress(completed, total_probes, host_ip, "1")
 
-    # ── Phase 2: HTTP probe on open ports to identify agent type ─────────────
+    # ── Phase 2: MCP protocol handshake on open ports ─────────────────────
     found: list[DiscoveredAgent] = []
-    for host_ip, port in open_targets:
-        agent = _probe_port(host_ip, port, timeout * 8)
-        if agent:
-            found.append(agent)
+    if open_targets:
+        p2_workers = min(20, len(open_targets))
+        with ThreadPoolExecutor(max_workers=p2_workers) as pool:
+            futures_p2 = {
+                pool.submit(_probe_mcp, h, p, timeout * 10, extra_headers): (h, p)
+                for h, p in open_targets
+            }
+            p2_done = 0
+            for future in as_completed(futures_p2):
+                agent = future.result()
+                if agent:
+                    found.append(agent)
+                p2_done += 1
+                if on_progress:
+                    h, p = futures_p2[future]
+                    on_progress(p2_done, len(open_targets), f"{h}:{p}", "2")
 
     elapsed = time.monotonic() - started_at
     stats = SubnetScanStats(
@@ -355,199 +377,96 @@ def scan_subnet(
     return found, stats
 
 
-# ── Port prober ───────────────────────────────────────────────────────────────
+# ── MCP protocol prober ───────────────────────────────────────────────────────
 
-def _probe_port(host: str, port: int, timeout: float) -> DiscoveredAgent | None:
-    """Make HTTP requests to an open port and detect what kind of agent it is."""
-    try:
-        import httpx
-    except ImportError:
-        return None
+def _probe_mcp(
+    host: str,
+    port: int,
+    timeout: float,
+    extra_headers: dict[str, str] | None = None,
+) -> DiscoveredAgent | None:
+    """Confirm a port is an MCP server by completing the initialize handshake.
+
+    Tries streamable-HTTP (POST) first; falls back to SSE (GET /sse) automatically.
+    A non-None return means the MCP protocol exchange succeeded or the server
+    explicitly rejected us with 401/403 — both confirm an MCP server is present.
+    """
+    from agentsentinel_cli.mcp_client import scan_http, McpAuthRequired, McpError
 
     base = f"http://{host}:{port}"
     location = f"{host}:{port}"
 
-    with httpx.Client(timeout=timeout, follow_redirects=False) as client:
-
-        # MCP SSE server
-        for path in _MCP_INDICATOR_PATHS:
-            try:
-                r = client.get(f"{base}{path}", headers={"Accept": "text/event-stream"})
-                if r.status_code < 500 and (
-                    "text/event-stream" in r.headers.get("content-type", "")
-                    or "event-stream" in r.text[:200]
-                    or r.status_code == 200
-                ):
-                    return DiscoveredAgent(
-                        source="network",
-                        name=f"mcp-server@{location}",
-                        framework="MCP Server",
-                        provider="",
-                        model="",
-                        location=location,
-                        api_keys=[],
-                        live_connections=[],
-                        risk="HIGH",
-                        risk_reason="MCP server with no authentication detected — inspect tools",
-                        next_step=f"sentinel mcp scan {base}/sse",
-                    )
-            except httpx.RequestError:
-                pass
-
-        # OpenAI-compatible API (Ollama, LiteLLM, vLLM, etc.)
-        for path in _OPENAI_COMPAT_PATHS:
-            try:
-                r = client.get(f"{base}{path}")
-                if r.status_code in (200, 401) and _looks_like_openai_api(r):
-                    model = _extract_model_from_response(r)
-                    auth_required = r.status_code == 401
-                    return DiscoveredAgent(
-                        source="network",
-                        name=f"llm-api@{location}",
-                        framework="OpenAI-compatible API",
-                        provider="",
-                        model=model,
-                        location=location,
-                        api_keys=[],
-                        live_connections=[],
-                        risk="LOW" if auth_required else "MEDIUM",
-                        risk_reason=(
-                            "OpenAI-compatible API (auth required)"
-                            if auth_required
-                            else "OpenAI-compatible API with no authentication — open access"
-                        ),
-                        next_step=f"sentinel scan --url {base}",
-                    )
-            except httpx.RequestError:
-                pass
-
-        # AgentSentinel platform
-        try:
-            r = client.get(f"{base}/health")
-            if r.status_code == 200 and r.text.strip().startswith("{"):
-                body = r.json()
-                if "status" in body:
-                    return DiscoveredAgent(
-                        source="network",
-                        name=f"agentsentinel@{location}",
-                        framework="AgentSentinel",
-                        provider="",
-                        model="",
-                        location=location,
-                        api_keys=[],
-                        live_connections=[],
-                        risk="LOW",
-                        risk_reason="AgentSentinel monitoring platform",
-                        next_step=f"sentinel scan --connect http://{location}",
-                    )
-        except (httpx.RequestError, Exception):
-            pass
-
-        # Generic agent API (LangChain server, FastAPI agent, etc.)
-        try:
-            r = client.get(f"{base}/api/v1/agents")
-            if r.status_code in (200, 401, 403):
-                auth_required = r.status_code in (401, 403)
-                return DiscoveredAgent(
-                    source="network",
-                    name=f"agent-api@{location}",
-                    framework="Unknown Agent API",
-                    provider="",
-                    model="",
-                    location=location,
-                    api_keys=[],
-                    live_connections=[],
-                    risk="MEDIUM" if not auth_required else "LOW",
-                    risk_reason=(
-                        "Agent API endpoint detected (auth required)"
-                        if auth_required
-                        else "Agent API endpoint with no authentication"
-                    ),
-                    next_step=f"sentinel scan --url {base}",
-                )
-        except httpx.RequestError:
-            pass
-
-    return None
-
-
-def _looks_like_openai_api(response) -> bool:
-    try:
-        body = response.json()
-        return "data" in body or "models" in body or "object" in body or "error" in body
-    except Exception:
-        return False
-
-
-def _extract_model_from_response(response) -> str:
     try:
-        data = response.json().get("data", [])
-        if data:
-            return data[0].get("id", "")
-    except Exception:
-        pass
-    return ""
-
-
-# ── File scanner ──────────────────────────────────────────────────────────────
-
-def scan_files(path: Path) -> list[DiscoveredAgent]:
-    """Find Python files in a directory that look like AI agents."""
-    from agentsentinel_cli.scanner import scan_path as static_scan
-
-    agents = static_scan(path)
-    found: list[DiscoveredAgent] = []
-
-    for agent in agents:
-        framework, provider = detect_framework(agent.file.read_text(errors="ignore"))
-        model = agent.model or detect_model(agent.file.read_text(errors="ignore"))
-        tool_count = len(agent.tools)
-        has_dangerous = any(t.is_dangerous for t in agent.tools)
-        has_creds = bool(agent.hardcoded_creds)
-
-        risk, risk_reason = _assess_file_risk(has_creds, has_dangerous, tool_count, framework)
-
-        found.append(DiscoveredAgent(
-            source="file",
-            name=agent.file.stem.replace("_", "-"),
-            framework=framework if framework != "Unknown" else _infer_framework_from_tools(agent),
-            provider=provider,
-            model=model,
-            location=str(agent.file),
-            api_keys=[f"HARDCODED: {c}" for c in agent.hardcoded_creds],
+        server = scan_http(base, extra_headers=extra_headers, timeout=timeout)
+    except McpAuthRequired:
+        # Server is MCP — it understood our handshake but requires credentials
+        scan_url = f"{base}/sse" if True else base  # SSE is dominant transport
+        return DiscoveredAgent(
+            source="network",
+            name=f"mcp-server@{location}",
+            framework="MCP Server",
+            provider="",
+            model="",
+            location=location,
+            api_keys=[],
             live_connections=[],
-            risk=risk,
-            risk_reason=risk_reason,
-            next_step=f"sentinel scan {agent.file}",
-        ))
-
-    return found
-
-
-def _infer_framework_from_tools(agent) -> str:
-    sources = {t.source for t in agent.tools}
-    if "BaseTool subclass" in sources or "StructuredTool" in str(sources):
-        return "LangChain"
-    if "@tool decorator" in sources:
-        return "LangChain / CrewAI"
-    return "Python agent"
+            risk="MEDIUM",
+            risk_reason="MCP server confirmed — authentication required, tools not enumerated",
+            next_step=(
+                f"sentinel mcp scan {base}/sse --auth-header 'Authorization: Bearer <token>'"
+            ),
+            tools=[],
+            transport="",
+        )
+    except McpError:
+        return None
+    except Exception:
+        return None
 
+    # Handshake succeeded — assess risk based on actual tool content
+    tool_names = [t.name for t in server.tools]
+    has_dangerous = any(t.is_dangerous for t in server.tools)
+    has_write = any(t.scope == "write" for t in server.tools)
+    auth_present = bool(extra_headers)
+
+    if not auth_present:
+        if has_dangerous or has_write:
+            risk = "CRITICAL"
+            risk_reason = (
+                f"Unauthenticated MCP server with dangerous/write tools: "
+                f"{', '.join(t.name for t in server.tools if t.is_dangerous or t.scope == 'write')}"
+            )
+        else:
+            risk = "HIGH"
+            risk_reason = (
+                f"Unauthenticated MCP server — {len(server.tools)} tool"
+                f"{'s' if len(server.tools) != 1 else ''} publicly accessible"
+            )
+    else:
+        risk = "LOW"
+        risk_reason = f"MCP server (authenticated) — {len(server.tools)} tool{'s' if len(server.tools) != 1 else ''} enumerated"
+
+    scan_url = f"{base}/sse" if server.transport == "sse" else base
+    auth_flag = (
+        f" --auth-header '{next(iter(extra_headers.items()))[0]}: ...'"
+        if extra_headers else ""
+    )
 
-def _assess_file_risk(
-    has_creds: bool,
-    has_dangerous: bool,
-    tool_count: int,
-    framework: str,
-) -> tuple[str, str]:
-    if has_creds:
-        return "CRITICAL", "Hardcoded credentials detected in source code — rotate immediately"
-    if has_dangerous:
-        return "HIGH", "Agent holds dangerous tool grants — run full scan"
-    if tool_count > 10:
-        return "MEDIUM", f"{tool_count} tool grants — excessive permissions, high blast radius"
-    if tool_count > 0:
-        return "LOW", f"{tool_count} tool grant{'s' if tool_count != 1 else ''} detected"
-    return "UNKNOWN", "Agent file detected — run full scan for analysis"
+    return DiscoveredAgent(
+        source="network",
+        name=server.name if server.name != "unknown" else f"mcp-server@{location}",
+        framework=f"MCP Server ({server.transport.upper()})",
+        provider="",
+        model="",
+        location=location,
+        api_keys=[],
+        live_connections=[],
+        risk=risk,
+        risk_reason=risk_reason,
+        next_step=f"sentinel mcp scan {scan_url}{auth_flag}",
+        tools=tool_names,
+        transport=server.transport,
+    )
 
 
 # ── Docker scanner ────────────────────────────────────────────────────────────
@@ -651,10 +570,10 @@ def run_discovery(
     do_process: bool = True,
     do_network: bool = True,
     do_docker: bool = False,
-    scan_path: Optional[Path] = None,
     ports: list[int] | None = None,
     subnet: Optional[str] = None,
-    subnet_progress_cb: Optional[Callable[[int, int, str], None]] = None,
+    extra_headers: dict[str, str] | None = None,
+    subnet_progress_cb: Optional[Callable[[int, int, str, str], None]] = None,
 ) -> tuple[list[DiscoveredAgent], Optional[SubnetScanStats]]:
     """Run all requested discovery scanners.
 
@@ -667,19 +586,17 @@ def run_discovery(
         results.extend(scan_processes())
 
     if do_network:
-        results.extend(scan_network(ports=ports))
+        results.extend(scan_network(ports=ports, extra_headers=extra_headers))
 
     if subnet:
         agents, subnet_stats = scan_subnet(
             cidr=subnet,
             ports=ports,
+            extra_headers=extra_headers,
             on_progress=subnet_progress_cb,
         )
         results.extend(agents)
 
-    if scan_path:
-        results.extend(scan_files(scan_path))
-
     if do_docker:
         results.extend(scan_docker())
 

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/discover_report.py

@@ -34,11 +34,12 @@ _SOURCE_LABEL = {
 }
 
 
-def print_subnet_progress(completed: int, total: int, current_ip: str) -> None:
+def print_subnet_progress(completed: int, total: int, current_ip: str, phase: str = "1") -> None:
     """Inline progress updater for subnet scan — overwrites the same line."""
     pct = int(completed / total * 100) if total else 0
+    label = "TCP sweep" if phase == "1" else "MCP handshake"
     console.print(
-        f"\r  [dim]Scanning {current_ip} … {pct}% ({completed}/{total})[/dim]",
+        f"\r  [dim]Phase {phase} {label}: {current_ip} … {pct}% ({completed}/{total})[/dim]",
         end="",
         highlight=False,
     )
@@ -71,7 +72,7 @@ def print_discover_result(
                 f"{subnet_stats.elapsed_seconds:.1f}s[/dim]"
             )
         console.print()
-        console.print("  [dim]Tip: use [bold]--path ./your/code[/bold] to scan source files, "
+        console.print("  [dim]Tip: use [bold]--subnet 10.0.0.0/24[/bold] to scan a network range, "
                       "or [bold]--docker[/bold] to inspect containers.[/dim]")
         console.print()
         return
@@ -136,6 +137,13 @@ def _print_agent(agent: DiscoveredAgent, verbose: bool) -> None:
         hosts = ", ".join(sorted(set(agent.live_connections)))
         console.print(f"  {'':>10}[dim]Live connections:[/dim] {hosts}")
 
+    # Enumerated tools (MCP network findings only)
+    if agent.tools:
+        tools_str = ", ".join(agent.tools[:8])
+        if len(agent.tools) > 8:
+            tools_str += f" (+{len(agent.tools) - 8} more)"
+        console.print(f"  {'':>10}[dim]Tools:[/dim] [cyan]{tools_str}[/cyan]")
+
     # Risk reason
     console.print(f"  {'':>10}[dim]{agent.risk_reason}[/dim]")
 
@@ -190,8 +198,8 @@ def _print_summary(
     if critical or high:
         console.print()
         console.print(
-            "  [dim]Run [bold]sentinel scan <file or --pid or --url>[/bold] "
-            "for a full posture analysis on any agent above.[/dim]"
+            "  [dim]Run [bold]sentinel mcp scan <url>[/bold] "
+            "for a full tool-by-tool security audit on any MCP server above.[/dim]"
         )
 
     if subnet_stats:

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/fingerprint.py

@@ -19,13 +19,18 @@ class AgentFingerprint:
     system_prompt_snippet: str = ""
     env_vars: list[str] = dataclasses.field(default_factory=list)
     external_apis: list[str] = dataclasses.field(default_factory=list)
-    server_type: str = "agent"   # "agent" | "mcp_server"
+    server_type: str = "agent"   # "agent" | "mcp_server" | "mcp_client"
 
 
-# MCP server SDK imports — presence means this is a tool provider, not an agent
+# Only server-side SDK modules — bare "mcp" and "mcp.types" are shared; "mcp.client.*" is a consumer
 _MCP_SERVER_IMPORTS = frozenset({
-    "mcp", "mcp.server", "mcp.server.fastmcp", "mcp.types",
-    "modelcontextprotocol", "fastmcp",
+    "mcp.server", "mcp.server.fastmcp", "fastmcp",
+})
+
+# Client-side SDK modules — this file consumes tools from an MCP server
+_MCP_CLIENT_IMPORTS = frozenset({
+    "mcp.client", "mcp.client.sse", "mcp.client.stdio",
+    "mcp.client.streamable_http", "mcp.client.websocket",
 })
 
 # Ordered by specificity — first match wins
@@ -127,12 +132,23 @@ class _FingerprintVisitor(ast.NodeVisitor):
                 if val and any(val.startswith(p) for p in _KNOWN_MODELS):
                     self.model = val
 
-        # os.environ.get("KEY") / os.getenv("KEY")
-        if func_name in ("get", "getenv") and node.args:
+        # os.getenv("KEY") — direct function call
+        if func_name == "getenv" and node.args:
             val = _get_str(node.args[0])
             if val and val not in self.env_vars:
                 self.env_vars.append(val)
 
+        # os.environ.get("KEY") — attribute chain: must be <name>.environ.get(...)
+        if func_name == "get" and node.args:
+            if (
+                isinstance(node.func, ast.Attribute)
+                and isinstance(node.func.value, ast.Attribute)
+                and node.func.value.attr == "environ"
+            ):
+                val = _get_str(node.args[0])
+                if val and val not in self.env_vars:
+                    self.env_vars.append(val)
+
         self.generic_visit(node)
 
     def visit_Constant(self, node: ast.Constant) -> None:
@@ -210,15 +226,29 @@ def fingerprint_file(path: Path) -> AgentFingerprint:
 
     cloud, deployment = _detect_cloud(v.imports, v.has_lambda_handler)
 
-    # Determine whether this is an MCP server (tool provider) or an AI agent (tool consumer)
+    def _matches(imp: str, prefix: str) -> bool:
+        return imp == prefix or imp.startswith(prefix + ".")
+
     is_mcp_server = any(
-        any(imp == mcp_imp or imp.startswith(mcp_imp + ".") for imp in v.imports)
-        for mcp_imp in _MCP_SERVER_IMPORTS
+        any(_matches(imp, p) for imp in v.imports) for p in _MCP_SERVER_IMPORTS
+    )
+    is_mcp_client = any(
+        any(_matches(imp, p) for imp in v.imports) for p in _MCP_CLIENT_IMPORTS
     )
-    server_type = "mcp_server" if is_mcp_server else "agent"
 
-    # MCP servers expose their framework label differently
-    framework = "MCP Server (FastMCP)" if is_mcp_server else _detect_framework(v.imports)
+    # A file with mcp.server.* is a tool provider; mcp.client.* is a tool consumer.
+    # If both appear the file is unusual (proxy/relay) — treat as server since it
+    # exposes tools.  Client-only → mcp_client, neither → agent.
+    if is_mcp_server:
+        server_type = "mcp_server"
+        has_fastmcp = any(_matches(imp, "mcp.server.fastmcp") or _matches(imp, "fastmcp") for imp in v.imports)
+        framework = "FastMCP" if has_fastmcp else "MCP Server"
+    elif is_mcp_client:
+        server_type = "mcp_client"
+        framework = _detect_framework(v.imports)
+    else:
+        server_type = "agent"
+        framework = _detect_framework(v.imports)
 
     return AgentFingerprint(
         framework=framework,

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/inspect.py

@@ -82,7 +82,7 @@ def _template_summary(
 ) -> str:
     """Generate a plain English summary without Claude — used as fallback."""
     if fingerprint.server_type == "mcp_server":
-        fw = fingerprint.framework if fingerprint.framework != "unknown" else "MCP server"
+        fw = fingerprint.framework if fingerprint.framework not in ("unknown", "") else "MCP server"
         parts: list[str] = [f"This is a {fw} — a tool provider with no LLM of its own."]
         parts.append("It exposes tools for AI agents to call.")
         if tools:
@@ -90,7 +90,16 @@ def _template_summary(
         parts.append("Run sentinel mcp scan against the live endpoint for a full security audit.")
         return " ".join(parts)
 
-    fw = fingerprint.framework if fingerprint.framework != "unknown" else "AI agent"
+    if fingerprint.server_type == "mcp_client":
+        fw = fingerprint.framework if fingerprint.framework not in ("unknown", "") else "agent"
+        model_str = f" using {fingerprint.model}" if fingerprint.model else ""
+        parts = [f"This is a {fw} MCP client{model_str}."]
+        parts.append("It connects to an external MCP server over the network to access tools.")
+        if fingerprint.system_prompt_found:
+            parts.append("A system prompt is configured for the LLM.")
+        return " ".join(parts)
+
+    fw = fingerprint.framework if fingerprint.framework not in ("unknown", "") else "AI agent"
     model_str = f" using {fingerprint.model}" if fingerprint.model else ""
 
     parts = []

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/inspect_report.py

@@ -55,14 +55,19 @@ def print_inspect_result(report: InspectReport) -> None:
     console.print()
     fp = report.fingerprint
 
-    type_label = (
-        "[bold yellow]MCP Server[/bold yellow] (tool provider — use sentinel mcp scan for full audit)"
-        if fp.server_type == "mcp_server"
-        else "[bold white]AI Agent[/bold white] (tool consumer with LLM)"
-    )
+    if fp.server_type == "mcp_server":
+        type_label = "[bold yellow]MCP Server[/bold yellow] (tool provider — use sentinel mcp scan for full audit)"
+        model_fallback = "[dim]n/a — MCP servers have no LLM[/dim]"
+    elif fp.server_type == "mcp_client":
+        type_label = "[bold cyan]MCP Client[/bold cyan] (agent that connects to an MCP server for tools)"
+        model_fallback = "[dim]not detected[/dim]"
+    else:
+        type_label = "[bold white]AI Agent[/bold white] (standalone LLM agent)"
+        model_fallback = "[dim]not detected[/dim]"
+
     _fp_row("Type",          type_label)
-    _fp_row("Framework",     fp.framework if fp.framework != "unknown" else "[dim]unknown[/dim]")
-    _fp_row("Model",         fp.model or ("[dim]n/a — MCP servers have no LLM[/dim]" if fp.server_type == "mcp_server" else "[dim]not detected[/dim]"))
+    _fp_row("Framework",     fp.framework if fp.framework not in ("unknown", "") else "[dim]unknown[/dim]")
+    _fp_row("Model",         fp.model or model_fallback)
     _fp_row("Python",        fp.python_version or "[dim]not detected[/dim]")
     _fp_row("Deployment",    fp.deployment if fp.deployment != "local" else "[dim]local[/dim]")
     _fp_row("Cloud",         fp.cloud if fp.cloud != "unknown" else "[dim]on-prem / unknown[/dim]")

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/agentsentinel_cli/mcp_client.py

@@ -108,8 +108,8 @@ def scan_http(
 
         if resp.status_code in (401, 403):
             raise McpAuthRequired(resp.status_code)
-        if resp.status_code == 405:
-            # Old SSE transport — fall back automatically
+        if resp.status_code in (404, 405):
+            # Server may use SSE transport — root path returns 404, /sse returns 405
             return scan_sse(url, extra_headers=extra_headers, timeout=timeout)
 
         content_type = resp.headers.get("content-type", "")

{agentsentinel_cli-0.7.1 → agentsentinel_cli-0.7.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentsentinel-cli"
-version = "0.7.1"
+version = "0.7.3"
 description = "Agentic security CLI — AI analyst with memory, supply chain audit, MCP audit, red-team probing, and agent discovery"
 readme = "README.md"
 requires-python = ">=3.10"