netallion-mcp-lite 0.1.0__tar.gz

netallion_mcp_lite-0.1.0/LICENSE

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

netallion_mcp_lite-0.1.0/MANIFEST.in

@@ -0,0 +1,11 @@
+include README.md
+include PRIVACY.md
+include LICENSE
+recursive-include src/netallion_mcp_lite *.py
+recursive-include src/netallion_mcp_lite py.typed
+# Never ship tests, scripts, or internal docs — they legitimately reference the
+# proprietary engine by name (as search terms / firewall assertions) and must
+# not end up in the public artifact.
+prune tests
+prune scripts
+prune docs

netallion_mcp_lite-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: netallion-mcp-lite
+Version: 0.1.0
+Summary: Free, local, IP-safe MCP server for AI-development security — commodity secret & credential checks from Netallion. Part of Agentic Development Governance.
+Author-email: Netallion <hello@netallion.ai>
+License: MIT
+Project-URL: Homepage, https://www.netallion.ai
+Project-URL: Documentation, https://www.netallion.ai
+Project-URL: Repository, https://github.com/netallion/netallion-mcp-lite
+Keywords: mcp,model-context-protocol,security,secrets,credentials,ai,agentic,governance,devsecops
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Dynamic: license-file
+
+# Netallion MCP Lite
+
+**Free, local, IP-safe AI-development security — an MCP server from Netallion.**
+
+Netallion MCP Lite is a small [Model Context Protocol](https://modelcontextprotocol.io) server that helps you and your AI coding assistants avoid the most common mistake in AI-assisted development: leaking a credential. It flags a curated set of **commodity, high-confidence** secrets and credentials (AWS, GitHub, Stripe, OpenAI, private keys, database URIs, and more) in text and files.
+
+It runs **entirely on your machine**. No account. No data sent to Netallion. Detected secrets are **redacted** before results are returned, so they are safe to hand back into an AI assistant's context.
+
+Part of Netallion's **Agentic Development Governance** approach — secret detection is one capability, not the whole story.
+
+---
+
+## What it is (and isn't)
+
+| | **Netallion MCP Lite** (this package) | **Netallion AI Assurance** (the platform) |
+|---|---|---|
+| Price | Free | Commercial (free trial) |
+| Runs | Locally, no account | SaaS + IDE + CI |
+| Detection | ~27 commodity, high-confidence checks | Advanced detection well beyond commodity patterns |
+| AI/MCP governance | — | AI provider governance, MCP governance |
+| Policy & visibility | — | Central policy management, org-wide visibility |
+| Compliance | — | Compliance and audit evidence |
+| Data | Nothing leaves your machine | Enterprise controls |
+
+MCP Lite is deliberately limited. It is a genuinely useful local utility **and** an on-ramp: if you want advanced detection, AI/MCP governance, central policy, and audit evidence across your organisation, that lives in **[Netallion AI Assurance](https://www.netallion.ai)**.
+
+This package does **not** contain or depend on Netallion's proprietary detection engine.
+
+---
+
+## Install & run
+
+Requires Python 3.10+.
+
+```bash
+pip install netallion-mcp-lite
+# or, zero-install:
+uvx netallion-mcp-lite
+```
+
+It speaks MCP over stdio. Add it to any MCP-compatible client (Claude, Cursor, Windsurf, VS Code, …):
+
+```json
+{
+  "mcpServers": {
+    "netallion-mcp-lite": {
+      "command": "netallion-mcp-lite"
+    }
+  }
+}
+```
+
+Optionally confine `scan_file` to a specific directory:
+
+```json
+{
+  "mcpServers": {
+    "netallion-mcp-lite": {
+      "command": "netallion-mcp-lite",
+      "env": { "NETALLION_MCP_LITE_WORKSPACE_ROOT": "/path/to/your/project" }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `scan_text` | Scan a string for commodity secrets; returns redacted findings (rule, severity, line/column, remediation). |
+| `scan_file` | Scan a file **inside the workspace root**; sensitive files (`.env`, keys) are refused; findings redacted. |
+| `list_supported_checks` | List the commodity checks (no secrets). |
+| `about` | About the tool, privacy posture, and Lite vs AI Assurance. |
+
+Run `list_supported_checks` to see the full set. Findings never include the full secret value.
+
+## Privacy
+
+Local-only. No telemetry. No source, file contents, prompts, or secrets are sent anywhere. See [PRIVACY.md](PRIVACY.md).
+
+## Scope & limitations
+
+- Commodity, high-confidence formats only — it will not catch obfuscated, encoded, or org-specific secrets. That is by design; advanced detection is part of Netallion AI Assurance.
+- `scan_file` reads only within a single workspace root and refuses obviously-sensitive files.
+- No generic high-entropy scanning (it produces noise without advanced technique).
+
+We make no claims about detection rates, false-positive rates, customer adoption, certifications, or regulatory compliance for this free utility.
+
+## Links
+
+- Netallion AI Assurance — https://www.netallion.ai
+- VS Code / Cursor / Windsurf extension — [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=netallion.netallion-ai-assurance) · [Open VSX](https://open-vsx.org/extension/netallion/netallion-ai-assurance)
+- Azure Marketplace — [Netallion AI Assurance](https://marketplace.microsoft.com/en-us/product/netallion.netallion-ai-assurance)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

netallion_mcp_lite-0.1.0/PRIVACY.md

@@ -0,0 +1,39 @@
+# Privacy & Data Flow — Netallion MCP Lite
+
+**Short version: everything runs locally. Nothing leaves your machine.**
+
+## What happens when you use it
+
+- `scan_text` and `scan_file` run entirely in-process using local regular
+  expressions. The text/file you scan is **never transmitted anywhere**.
+- No source code, file contents, prompts, secrets, or credentials are sent to
+  Netallion or any third party.
+- Detected secret values are **redacted** before results are returned, so even
+  the tool's own output does not contain full credentials.
+
+## Telemetry
+
+- **None.** This package sends no usage analytics, no pings, no crash reports.
+- There is no network client in the core scanner.
+
+## Network
+
+- Core scanning makes **no network calls**.
+- The only time anything is fetched from the network is at *install* time, when
+  your package manager downloads this package and its single public dependency
+  (the MCP SDK) from your configured package index.
+
+## Data retention
+
+- The tool stores nothing. It holds the text you pass it in memory only for the
+  duration of a scan.
+
+## Future optional features
+
+- If any optional outbound feature is ever added (for example, connecting to
+  Netallion AI Assurance), it will be **explicitly opt-in**, off by default, and
+  documented separately. The core Lite scanner will always work fully offline.
+
+## Contact
+
+Questions: https://www.netallion.ai

netallion_mcp_lite-0.1.0/README.md

@@ -0,0 +1,97 @@
+# Netallion MCP Lite
+
+**Free, local, IP-safe AI-development security — an MCP server from Netallion.**
+
+Netallion MCP Lite is a small [Model Context Protocol](https://modelcontextprotocol.io) server that helps you and your AI coding assistants avoid the most common mistake in AI-assisted development: leaking a credential. It flags a curated set of **commodity, high-confidence** secrets and credentials (AWS, GitHub, Stripe, OpenAI, private keys, database URIs, and more) in text and files.
+
+It runs **entirely on your machine**. No account. No data sent to Netallion. Detected secrets are **redacted** before results are returned, so they are safe to hand back into an AI assistant's context.
+
+Part of Netallion's **Agentic Development Governance** approach — secret detection is one capability, not the whole story.
+
+---
+
+## What it is (and isn't)
+
+| | **Netallion MCP Lite** (this package) | **Netallion AI Assurance** (the platform) |
+|---|---|---|
+| Price | Free | Commercial (free trial) |
+| Runs | Locally, no account | SaaS + IDE + CI |
+| Detection | ~27 commodity, high-confidence checks | Advanced detection well beyond commodity patterns |
+| AI/MCP governance | — | AI provider governance, MCP governance |
+| Policy & visibility | — | Central policy management, org-wide visibility |
+| Compliance | — | Compliance and audit evidence |
+| Data | Nothing leaves your machine | Enterprise controls |
+
+MCP Lite is deliberately limited. It is a genuinely useful local utility **and** an on-ramp: if you want advanced detection, AI/MCP governance, central policy, and audit evidence across your organisation, that lives in **[Netallion AI Assurance](https://www.netallion.ai)**.
+
+This package does **not** contain or depend on Netallion's proprietary detection engine.
+
+---
+
+## Install & run
+
+Requires Python 3.10+.
+
+```bash
+pip install netallion-mcp-lite
+# or, zero-install:
+uvx netallion-mcp-lite
+```
+
+It speaks MCP over stdio. Add it to any MCP-compatible client (Claude, Cursor, Windsurf, VS Code, …):
+
+```json
+{
+  "mcpServers": {
+    "netallion-mcp-lite": {
+      "command": "netallion-mcp-lite"
+    }
+  }
+}
+```
+
+Optionally confine `scan_file` to a specific directory:
+
+```json
+{
+  "mcpServers": {
+    "netallion-mcp-lite": {
+      "command": "netallion-mcp-lite",
+      "env": { "NETALLION_MCP_LITE_WORKSPACE_ROOT": "/path/to/your/project" }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `scan_text` | Scan a string for commodity secrets; returns redacted findings (rule, severity, line/column, remediation). |
+| `scan_file` | Scan a file **inside the workspace root**; sensitive files (`.env`, keys) are refused; findings redacted. |
+| `list_supported_checks` | List the commodity checks (no secrets). |
+| `about` | About the tool, privacy posture, and Lite vs AI Assurance. |
+
+Run `list_supported_checks` to see the full set. Findings never include the full secret value.
+
+## Privacy
+
+Local-only. No telemetry. No source, file contents, prompts, or secrets are sent anywhere. See [PRIVACY.md](PRIVACY.md).
+
+## Scope & limitations
+
+- Commodity, high-confidence formats only — it will not catch obfuscated, encoded, or org-specific secrets. That is by design; advanced detection is part of Netallion AI Assurance.
+- `scan_file` reads only within a single workspace root and refuses obviously-sensitive files.
+- No generic high-entropy scanning (it produces noise without advanced technique).
+
+We make no claims about detection rates, false-positive rates, customer adoption, certifications, or regulatory compliance for this free utility.
+
+## Links
+
+- Netallion AI Assurance — https://www.netallion.ai
+- VS Code / Cursor / Windsurf extension — [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=netallion.netallion-ai-assurance) · [Open VSX](https://open-vsx.org/extension/netallion/netallion-ai-assurance)
+- Azure Marketplace — [Netallion AI Assurance](https://marketplace.microsoft.com/en-us/product/netallion.netallion-ai-assurance)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

netallion_mcp_lite-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "netallion-mcp-lite"
+version = "0.1.0"
+description = "Free, local, IP-safe MCP server for AI-development security — commodity secret & credential checks from Netallion. Part of Agentic Development Governance."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Netallion", email = "hello@netallion.ai" }]
+keywords = [
+    "mcp",
+    "model-context-protocol",
+    "security",
+    "secrets",
+    "credentials",
+    "ai",
+    "agentic",
+    "governance",
+    "devsecops",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Security",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+# IP FIREWALL: the ONLY runtime dependency is the public MCP SDK.
+# Never add the proprietary Netallion detection engine or any private
+# Netallion package here. The firewall test and CI enforce this.
+dependencies = [
+    "mcp>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://www.netallion.ai"
+Documentation = "https://www.netallion.ai"
+Repository = "https://github.com/netallion/netallion-mcp-lite"
+
+[project.scripts]
+netallion-mcp-lite = "netallion_mcp_lite.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+netallion_mcp_lite = ["py.typed"]

netallion_mcp_lite-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite/__init__.py

@@ -0,0 +1,19 @@
+"""Netallion MCP Lite — free, local, IP-safe AI-development security.
+
+A standalone Model Context Protocol server that scans text and files for a
+curated set of *commodity*, high-confidence secret/credential formats — the
+kind that are already publicly documented across the ecosystem. It runs fully
+locally, sends nothing to Netallion, and requires no account.
+
+This package is intentionally isolated from Netallion's proprietary detection
+engine. It is a developer utility and an on-ramp to Netallion AI Assurance —
+the enterprise Agentic Development Governance platform — not a reimplementation
+of it. See README.md for the Lite vs AI Assurance distinction.
+"""
+
+__version__ = "0.1.0"
+
+from netallion_mcp_lite.rules import RULES
+from netallion_mcp_lite.scanner import Finding, scan_text
+
+__all__ = ["RULES", "Finding", "scan_text", "__version__"]

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite/redaction.py

@@ -0,0 +1,30 @@
+"""Redaction helpers.
+
+CRITICAL: results from this package are intended to be handed back into an LLM
+context (that is what an MCP tool result is). We therefore never return a full
+secret value. Every detected secret is masked before it leaves the scanner.
+"""
+
+from __future__ import annotations
+
+
+def redact(secret: str) -> str:
+    """Mask a secret for safe display.
+
+    Short values are fully masked; longer values keep a tiny prefix/suffix so a
+    human can correlate the finding without the value ever being usable.
+    """
+    s = secret.strip()
+    if not s:
+        return ""
+    n = len(s)
+    if n <= 8:
+        return "*" * n
+    # Reveal only a small prefix/suffix — never more than ~1/3 of the value, and
+    # for short values (9-11 chars) reveal a prefix only.
+    head_len = 4 if n >= 16 else 2
+    tail_len = 2 if n >= 12 else 0
+    head = s[:head_len]
+    tail = s[-tail_len:] if tail_len else ""
+    stars = min(n - head_len - tail_len, 12)
+    return f"{head}{'*' * stars}{tail}"

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite/rules.py

@@ -0,0 +1,330 @@
+"""Commodity detection rules for Netallion MCP Lite.
+
+INTENTIONALLY PUBLIC. Every rule here matches a credential/secret format that
+is already widely documented in open tools and vendor docs (AWS, GitHub, Stripe,
+etc.). None of this logic is derived from, copied from, or dependent on
+Netallion's proprietary detection engine. The differentiated technology —
+the full pattern corpus, BPE detection, live verifiers, FP classification, and
+runtime AI-threat rules — lives exclusively in Netallion AI Assurance and is
+NOT present in this package.
+
+Design test applied to every rule: "Would we be comfortable publishing this
+exact detection logic permanently on GitHub for competitors to copy?" Only
+rules that pass are included. High-entropy/BPE-style generic detection is
+deliberately excluded — it cannot be done well without proprietary technique.
+
+Patterns are written to be simple and linear-time (no nested/ambiguous
+quantifiers) to avoid catastrophic backtracking.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+Severity = str  # "critical" | "high" | "medium" | "low"
+
+
+@dataclass(frozen=True)
+class Rule:
+    """A single commodity detection rule."""
+
+    id: str
+    name: str
+    severity: Severity
+    description: str
+    pattern: re.Pattern[str]
+    remediation: str
+    # 1-based index of the capture group holding the secret to redact; 0 = whole match.
+    secret_group: int = 0
+    tags: tuple[str, ...] = field(default_factory=tuple)
+
+
+_ROTATE = (
+    "Revoke/rotate this credential at the provider, remove it from the code or "
+    "config, and load it from a secret manager or environment variable instead."
+)
+
+# ---------------------------------------------------------------------------
+# Rules — commodity, high-confidence formats only.
+# ---------------------------------------------------------------------------
+RULES: tuple[Rule, ...] = (
+    Rule(
+        id="aws-access-key-id",
+        name="AWS Access Key ID",
+        severity="high",
+        description="Amazon Web Services access key identifier (AKIA/ASIA prefix).",
+        pattern=re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b"),
+        remediation="Deactivate the key in AWS IAM and issue a replacement. " + _ROTATE,
+        tags=("cloud", "aws"),
+    ),
+    Rule(
+        id="aws-secret-access-key",
+        name="AWS Secret Access Key (assignment)",
+        severity="high",
+        description="A 40-char AWS secret access key assigned to an aws_secret_access_key field.",
+        pattern=re.compile(
+            r"(?i)aws_secret_access_key\s*[:=]\s*[\"']?([A-Za-z0-9/+]{40})[\"']?"
+        ),
+        remediation="Rotate the AWS secret access key immediately in IAM. " + _ROTATE,
+        secret_group=1,
+        tags=("cloud", "aws"),
+    ),
+    Rule(
+        id="github-pat-classic",
+        name="GitHub Personal Access Token (classic)",
+        severity="high",
+        description="GitHub classic personal access token (ghp_ prefix).",
+        pattern=re.compile(r"\bghp_[A-Za-z0-9]{36}\b"),
+        remediation="Revoke the token in GitHub Developer settings. " + _ROTATE,
+        tags=("vcs", "github"),
+    ),
+    Rule(
+        id="github-oauth-token",
+        name="GitHub OAuth Access Token",
+        severity="high",
+        description="GitHub OAuth access token (gho_ prefix).",
+        pattern=re.compile(r"\bgho_[A-Za-z0-9]{36}\b"),
+        remediation=_ROTATE,
+        tags=("vcs", "github"),
+    ),
+    Rule(
+        id="github-app-token",
+        name="GitHub App Token",
+        severity="high",
+        description="GitHub app user-to-server / server-to-server token (ghu_/ghs_ prefix).",
+        pattern=re.compile(r"\b(?:ghu|ghs)_[A-Za-z0-9]{36}\b"),
+        remediation=_ROTATE,
+        tags=("vcs", "github"),
+    ),
+    Rule(
+        id="github-refresh-token",
+        name="GitHub Refresh Token",
+        severity="medium",
+        description="GitHub refresh token (ghr_ prefix).",
+        pattern=re.compile(r"\bghr_[A-Za-z0-9]{36}\b"),
+        remediation=_ROTATE,
+        tags=("vcs", "github"),
+    ),
+    Rule(
+        id="github-fine-grained-pat",
+        name="GitHub Fine-Grained PAT",
+        severity="high",
+        description="GitHub fine-grained personal access token (github_pat_ prefix).",
+        pattern=re.compile(r"\bgithub_pat_[A-Za-z0-9_]{82}\b"),
+        remediation="Revoke the fine-grained token in GitHub Developer settings. " + _ROTATE,
+        tags=("vcs", "github"),
+    ),
+    Rule(
+        id="gitlab-pat",
+        name="GitLab Personal Access Token",
+        severity="high",
+        description="GitLab personal access token (glpat- prefix).",
+        pattern=re.compile(r"\bglpat-[A-Za-z0-9_\-]{20}\b"),
+        remediation="Revoke the token in GitLab access-token settings. " + _ROTATE,
+        tags=("vcs", "gitlab"),
+    ),
+    Rule(
+        id="openai-api-key",
+        name="OpenAI API Key",
+        severity="high",
+        description="OpenAI API key (sk- prefix, incl. sk-proj-/sk-svcacct- with _/- in the body).",
+        # Two precise forms: a known modern prefix (proj-/svcacct-/admin-) with a
+        # long body, OR the classic long all-alphanumeric key. Matches real keys
+        # without flagging ordinary sk-<kebab-case> identifiers.
+        pattern=re.compile(
+            r"\bsk-(?:proj|svcacct|admin)-[A-Za-z0-9_-]{20,}\b"
+            r"|\bsk-[A-Za-z0-9]{32,}\b"
+        ),
+        remediation="Revoke the key in the OpenAI dashboard. " + _ROTATE,
+        tags=("ai", "openai"),
+    ),
+    Rule(
+        id="anthropic-api-key",
+        name="Anthropic API Key",
+        severity="high",
+        description="Anthropic API key (sk-ant- prefix).",
+        pattern=re.compile(r"\bsk-ant-[A-Za-z0-9_\-]{80,}\b"),
+        remediation="Revoke the key in the Anthropic console. " + _ROTATE,
+        tags=("ai", "anthropic"),
+    ),
+    Rule(
+        id="google-api-key",
+        name="Google API Key",
+        severity="high",
+        description="Google API key (AIza prefix).",
+        pattern=re.compile(r"\bAIza[0-9A-Za-z_\-]{35}\b"),
+        remediation="Regenerate the key in the Google Cloud console. " + _ROTATE,
+        tags=("cloud", "google"),
+    ),
+    Rule(
+        id="slack-token",
+        name="Slack Token",
+        severity="high",
+        description="Slack API token (xoxb/xoxa/xoxp/xoxr/xoxs prefix).",
+        pattern=re.compile(r"\bxox[baprs]-[A-Za-z0-9\-]{10,}\b"),
+        remediation="Revoke the token in Slack app settings. " + _ROTATE,
+        tags=("saas", "slack"),
+    ),
+    Rule(
+        id="slack-webhook-url",
+        name="Slack Incoming Webhook URL",
+        severity="medium",
+        description="Slack incoming webhook URL (hooks.slack.com/services/...).",
+        pattern=re.compile(
+            r"https://hooks\.slack\.com/services/T[A-Za-z0-9_]+/B[A-Za-z0-9_]+/[A-Za-z0-9_]{20,}"
+        ),
+        remediation="Delete and recreate the webhook in Slack. " + _ROTATE,
+        tags=("saas", "slack"),
+    ),
+    Rule(
+        id="stripe-live-secret-key",
+        name="Stripe Live Secret Key",
+        severity="critical",
+        description="Stripe live-mode secret/restricted key (sk_live_/rk_live_).",
+        pattern=re.compile(r"\b(?:sk|rk)_live_[0-9a-zA-Z]{24,}\b"),
+        remediation="Roll the key in the Stripe dashboard immediately. " + _ROTATE,
+        tags=("payments", "stripe"),
+    ),
+    Rule(
+        id="stripe-test-secret-key",
+        name="Stripe Test Secret Key",
+        severity="low",
+        description="Stripe test-mode secret/restricted key (sk_test_/rk_test_).",
+        pattern=re.compile(r"\b(?:sk|rk)_test_[0-9a-zA-Z]{24,}\b"),
+        remediation="Test-mode key — still remove from source and roll if unsure. " + _ROTATE,
+        tags=("payments", "stripe"),
+    ),
+    Rule(
+        id="twilio-api-key",
+        name="Twilio API Key SID",
+        severity="high",
+        description="Twilio API key SID (SK + 32 hex).",
+        pattern=re.compile(r"\bSK[0-9a-fA-F]{32}\b"),
+        remediation="Delete the API key in the Twilio console. " + _ROTATE,
+        tags=("saas", "twilio"),
+    ),
+    Rule(
+        id="twilio-account-sid",
+        name="Twilio Account SID",
+        severity="medium",
+        description="Twilio account SID (AC + 32 hex).",
+        pattern=re.compile(r"\bAC[0-9a-fA-F]{32}\b"),
+        remediation="Account SID is an identifier; ensure the paired auth token is not exposed.",
+        tags=("saas", "twilio"),
+    ),
+    Rule(
+        id="sendgrid-api-key",
+        name="SendGrid API Key",
+        severity="high",
+        description="SendGrid API key (SG. prefix).",
+        pattern=re.compile(r"\bSG\.[A-Za-z0-9_\-]{22}\.[A-Za-z0-9_\-]{43}\b"),
+        remediation="Delete the key in SendGrid settings. " + _ROTATE,
+        tags=("saas", "sendgrid"),
+    ),
+    Rule(
+        id="npm-access-token",
+        name="npm Access Token",
+        severity="high",
+        description="npm access token (npm_ prefix).",
+        pattern=re.compile(r"\bnpm_[A-Za-z0-9]{36}\b"),
+        remediation="Revoke the token in your npm account settings. " + _ROTATE,
+        tags=("package", "npm"),
+    ),
+    Rule(
+        id="pem-private-key",
+        name="Private Key (PEM header)",
+        severity="critical",
+        description="A PEM-encoded private key block header.",
+        pattern=re.compile(
+            r"-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP |ENCRYPTED )?PRIVATE KEY-----"
+        ),
+        remediation="Treat the key as compromised: rotate the key pair and revoke any certs. " + _ROTATE,
+        tags=("crypto", "private-key"),
+    ),
+    Rule(
+        id="jwt",
+        name="JSON Web Token",
+        # Low severity: JWTs are structural (not inherently secret), so this is a
+        # low-confidence signal. Severity communicates that confidence for now.
+        severity="low",
+        description="A JWT (three base64url segments, header starts with eyJ).",
+        pattern=re.compile(r"\beyJ[A-Za-z0-9_\-]{10,}\.eyJ[A-Za-z0-9_\-]{10,}\.[A-Za-z0-9_\-]{10,}\b"),
+        remediation="If this token grants access, invalidate the session/signing key. " + _ROTATE,
+        tags=("token", "jwt"),
+    ),
+    Rule(
+        id="db-connection-uri",
+        name="Database Connection URI with Credentials",
+        severity="high",
+        description="A database URI with an embedded username:password (postgres/mysql/mongodb/redis/amqp).",
+        pattern=re.compile(
+            r"\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqp)://[^\s:@/]+:[^\s:@/]+@[^\s/]+"
+        ),
+        remediation="Rotate the database password and move the URI to a secret manager. " + _ROTATE,
+        tags=("database",),
+    ),
+    Rule(
+        id="authorization-bearer",
+        name="Authorization Bearer Token",
+        severity="medium",
+        description="An Authorization header assigning a Bearer token.",
+        pattern=re.compile(
+            r"(?i)authorization\s*[:=]\s*[\"']?bearer\s+([A-Za-z0-9\-._~+/]{20,}={0,2})"
+        ),
+        remediation="Rotate the bearer token/credential it represents. " + _ROTATE,
+        secret_group=1,
+        tags=("token",),
+    ),
+    Rule(
+        id="generic-api-key-assignment",
+        name="Generic API Key / Token Assignment",
+        # Low severity/confidence: also matches placeholders/examples.
+        severity="low",
+        description="A quoted value assigned to an api_key / secret_key / access_token style field.",
+        pattern=re.compile(
+            r"(?i)\b(?:api[_-]?key|secret[_-]?key|access[_-]?token|auth[_-]?token)\b\s*[:=]\s*[\"']([A-Za-z0-9\-_]{16,})[\"']"
+        ),
+        remediation="Confirm whether this is a live secret; if so, rotate it. " + _ROTATE,
+        secret_group=1,
+        tags=("generic",),
+    ),
+    Rule(
+        id="generic-password-assignment",
+        name="Hardcoded Password Assignment",
+        severity="low",
+        description="A quoted value assigned to a password / passwd / pwd field.",
+        pattern=re.compile(
+            r"(?i)\b(?:password|passwd|pwd)\b\s*[:=]\s*[\"']([^\"']{6,})[\"']"
+        ),
+        remediation="Do not hardcode passwords; load from a secret manager and rotate if real.",
+        secret_group=1,
+        tags=("generic",),
+    ),
+    Rule(
+        id="azure-storage-account-key",
+        name="Azure Storage Account Key",
+        severity="high",
+        description="An Azure Storage AccountKey= value (88-char base64).",
+        pattern=re.compile(r"(?i)AccountKey\s*=\s*([A-Za-z0-9+/]{86,}==)"),
+        remediation="Regenerate the storage account key in the Azure portal. " + _ROTATE,
+        secret_group=1,
+        tags=("cloud", "azure"),
+    ),
+    Rule(
+        id="telegram-bot-token",
+        name="Telegram Bot Token",
+        severity="medium",
+        description="A Telegram bot token (numeric id : 35-char secret).",
+        pattern=re.compile(r"\b\d{8,10}:[A-Za-z0-9_\-]{35}\b"),
+        remediation="Revoke the bot token via BotFather (/revoke). " + _ROTATE,
+        tags=("saas", "telegram"),
+    ),
+)
+
+
+def rule_by_id(rule_id: str) -> Rule | None:
+    for rule in RULES:
+        if rule.id == rule_id:
+            return rule
+    return None

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite/scanner.py

@@ -0,0 +1,72 @@
+"""Local scanning engine for Netallion MCP Lite.
+
+Runs entirely in-process. No network calls, no telemetry, no dependency on the
+Netallion platform. Matched secrets are redacted before being returned.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+from netallion_mcp_lite.redaction import redact
+from netallion_mcp_lite.rules import RULES
+
+# Cap how much text we scan per call to keep behaviour predictable and fast.
+MAX_SCAN_CHARS = 5_000_000  # ~5M characters
+
+
+@dataclass(frozen=True)
+class Finding:
+    rule_id: str
+    rule_name: str
+    severity: str
+    line: int
+    column: int
+    redacted_preview: str
+    remediation: str
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def _secret_from_match(match, secret_group: int) -> str:
+    if secret_group and match.lastindex and secret_group <= match.lastindex:
+        value = match.group(secret_group)
+        if value is not None:
+            return value
+    return match.group(0)
+
+
+def scan_text(text: str, source: str = "text") -> list[Finding]:
+    """Scan text line by line and return redacted findings, ordered by location."""
+    if not text:
+        return []
+    if len(text) > MAX_SCAN_CHARS:
+        text = text[:MAX_SCAN_CHARS]
+
+    findings: list[Finding] = []
+    for line_no, line in enumerate(text.splitlines(), start=1):
+        for rule in RULES:
+            for match in rule.pattern.finditer(line):
+                secret = _secret_from_match(match, rule.secret_group)
+                findings.append(
+                    Finding(
+                        rule_id=rule.id,
+                        rule_name=rule.name,
+                        severity=rule.severity,
+                        line=line_no,
+                        column=match.start() + 1,
+                        redacted_preview=redact(secret),
+                        remediation=rule.remediation,
+                    )
+                )
+    findings.sort(key=lambda f: (f.line, f.column, f.rule_id))
+    return findings
+
+
+def summarize(findings: list[Finding]) -> dict[str, int]:
+    """Count findings by severity."""
+    counts: dict[str, int] = {}
+    for f in findings:
+        counts[f.severity] = counts.get(f.severity, 0) + 1
+    return counts

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite/server.py

@@ -0,0 +1,289 @@
+"""Netallion MCP Lite — standards-compliant MCP server (stdio).
+
+Exposes four tools: scan_text, scan_file, list_supported_checks, about.
+Everything runs locally; no secrets or source ever leave the machine, and all
+detected secret material is redacted before being returned to the caller.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+from mcp.types import TextContent, Tool
+
+from netallion_mcp_lite import __version__
+from netallion_mcp_lite.rules import RULES
+from netallion_mcp_lite.scanner import scan_text as _scan_text
+from netallion_mcp_lite.scanner import summarize
+
+# Files we refuse to read even inside the workspace — reading them would defeat
+# the point (and their contents would flow back into an LLM context).
+_BLOCKED_NAMES = {".env", "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519", "credentials"}
+_BLOCKED_SUFFIXES = (".env", ".key", ".pem", ".p12", ".pfx", ".keystore")
+# Example/template env files hold placeholders, not real secrets — safe to scan.
+_ENV_EXAMPLE_NAMES = {".env.example", ".env.sample", ".env.template", ".env.dist"}
+_MAX_FILE_BYTES = 10_000_000  # 10 MB
+
+_ATTRIBUTION = {
+    "product": "Netallion MCP Lite",
+    "tagline": "Free, local, IP-safe AI-development security.",
+    "learn_more": "https://www.netallion.ai",
+    "vs_code_extension": (
+        "https://marketplace.visualstudio.com/items?itemName=netallion.netallion-ai-assurance"
+    ),
+    "azure_marketplace": (
+        "https://marketplace.microsoft.com/en-us/product/netallion.netallion-ai-assurance"
+    ),
+}
+
+
+def _allowed_root() -> Path:
+    """The single directory tree scan_file may read.
+
+    Defaults to the process working directory (the opened workspace). Override
+    with NETALLION_MCP_LITE_WORKSPACE_ROOT for explicit confinement.
+    """
+    root = os.environ.get("NETALLION_MCP_LITE_WORKSPACE_ROOT")
+    return Path(root).resolve() if root else Path.cwd().resolve()
+
+
+def _root_is_too_broad(root: Path) -> bool:
+    """A filesystem anchor ('/', 'C:\\') or a home directory is too broad to be a
+    safe allowlist — a globally-installed server launched with such a cwd would
+    otherwise expose ~/.aws, ~/.ssh, etc.
+    """
+    try:
+        home = Path.home().resolve()
+    except (RuntimeError, OSError):
+        home = None
+    return root == Path(root.anchor) or (
+        home is not None and (root == home or root in home.parents)
+    )
+
+
+def _is_within(path: Path, root: Path) -> bool:
+    try:
+        path.relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def _err(message: str) -> list[TextContent]:
+    return [TextContent(type="text", text=json.dumps({"error": message}))]
+
+
+def _handle_scan_text(arguments: dict[str, Any]) -> list[TextContent]:
+    text = arguments.get("text", "")
+    source = arguments.get("source", "text")
+    if not isinstance(text, str) or not text:
+        return [TextContent(type="text", text=json.dumps({"findings": [], "count": 0}))]
+
+    findings = _scan_text(text, source=str(source))
+    payload = {
+        "source": str(source),
+        "count": len(findings),
+        "summary": summarize(findings),
+        "findings": [f.as_dict() for f in findings],
+        "note": "Commodity checks only (Netallion MCP Lite). Secret values are redacted.",
+    }
+    return [TextContent(type="text", text=json.dumps(payload, indent=2))]
+
+
+def _handle_scan_file(arguments: dict[str, Any]) -> list[TextContent]:
+    file_path = arguments.get("path", "")
+    if not file_path or not isinstance(file_path, str):
+        return _err("No path provided")
+
+    # .resolve() collapses '..' AND resolves symlinks, so an in-workspace symlink
+    # pointing outside resolves to its real (out-of-root) target and is rejected.
+    path = Path(file_path).resolve()
+    root = _allowed_root()
+
+    if _root_is_too_broad(root):
+        return _err(
+            "scan_file disabled: workspace root is too broad (filesystem/home root). "
+            "Set NETALLION_MCP_LITE_WORKSPACE_ROOT to the workspace directory."
+        )
+    if not _is_within(path, root):
+        return _err("Access denied: path is outside the allowed workspace root")
+    name = path.name
+    if (
+        name in _BLOCKED_NAMES
+        # .env, .env.local, .env.production, ... but allow .env.example/.sample/etc.
+        or (name.startswith(".env") and name not in _ENV_EXAMPLE_NAMES)
+        or any(name.endswith(s) for s in _BLOCKED_SUFFIXES)
+    ):
+        return _err("Access denied: sensitive file type is not read by scan_file")
+    if not path.exists():
+        return _err(f"File not found: {file_path}")
+    if not path.is_file():
+        return _err(f"Not a file: {file_path}")
+    if path.stat().st_size > _MAX_FILE_BYTES:
+        return _err("File too large (>10MB)")
+
+    try:
+        text = path.read_text(errors="replace")
+    except OSError as exc:
+        return _err(f"Cannot read file: {exc}")
+
+    findings = _scan_text(text, source=str(path))
+    payload = {
+        "path": str(path),
+        "count": len(findings),
+        "summary": summarize(findings),
+        "findings": [f.as_dict() for f in findings],
+        "note": "Commodity checks only (Netallion MCP Lite). Secret values are redacted.",
+    }
+    return [TextContent(type="text", text=json.dumps(payload, indent=2))]
+
+
+def _handle_list_supported_checks() -> list[TextContent]:
+    payload = {
+        "count": len(RULES),
+        "checks": [
+            {
+                "id": r.id,
+                "name": r.name,
+                "severity": r.severity,
+                "description": r.description,
+                "tags": list(r.tags),
+            }
+            for r in RULES
+        ],
+        "note": (
+            "These are commodity, publicly-documented credential formats. "
+            "Netallion AI Assurance adds advanced detection, AI/MCP governance, "
+            "policy management, and compliance evidence."
+        ),
+    }
+    return [TextContent(type="text", text=json.dumps(payload, indent=2))]
+
+
+def _handle_about() -> list[TextContent]:
+    payload = {
+        **_ATTRIBUTION,
+        "version": __version__,
+        "what_this_is": (
+            "Netallion MCP Lite is a free, local MCP server that flags a curated set "
+            "of commodity, high-confidence secrets and credentials as you and your AI "
+            "assistants work. It runs entirely on your machine — no account, no data "
+            "sent to Netallion."
+        ),
+        "lite_vs_ai_assurance": {
+            "netallion_mcp_lite": [
+                "Free and local; no account required",
+                "~27 commodity, high-confidence credential checks",
+                "No source/secrets ever uploaded",
+            ],
+            "netallion_ai_assurance": [
+                "Enterprise Agentic Development Governance platform",
+                "Advanced detection beyond commodity patterns",
+                "AI provider governance and MCP governance",
+                "Central policy management and organisational visibility",
+                "Compliance and audit evidence",
+            ],
+        },
+        "privacy": "Local-only scanning. No telemetry. See PRIVACY.md.",
+    }
+    return [TextContent(type="text", text=json.dumps(payload, indent=2))]
+
+
+def _dispatch(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+    """Route a tool call by name. Module-level so the unknown-tool path is testable."""
+    if name == "scan_text":
+        return _handle_scan_text(arguments)
+    if name == "scan_file":
+        return _handle_scan_file(arguments)
+    if name == "list_supported_checks":
+        return _handle_list_supported_checks()
+    if name == "about":
+        return _handle_about()
+    return _err(f"Unknown tool: {name}")
+
+
+def create_server() -> Server:
+    server: Server = Server("netallion-mcp-lite")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name="scan_text",
+                description=(
+                    "Scan text locally for commodity secrets and credentials "
+                    "(AWS/GitHub/Stripe/etc.). Returns redacted findings with rule id, "
+                    "severity, location, and remediation. Nothing is uploaded."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "text": {"type": "string", "description": "Text to scan."},
+                        "source": {
+                            "type": "string",
+                            "description": "Optional label for the source (e.g. filename).",
+                            "default": "text",
+                        },
+                    },
+                    "required": ["text"],
+                },
+            ),
+            Tool(
+                name="scan_file",
+                description=(
+                    "Scan a file inside the current workspace for commodity secrets. "
+                    "Confined to the workspace root; sensitive files (.env, keys) are "
+                    "refused. Returns redacted findings."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "path": {
+                            "type": "string",
+                            "description": "Path to a file within the workspace root.",
+                        }
+                    },
+                    "required": ["path"],
+                },
+            ),
+            Tool(
+                name="list_supported_checks",
+                description="List the commodity checks this Lite server supports (no secrets).",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            Tool(
+                name="about",
+                description=(
+                    "About Netallion MCP Lite, privacy posture, and how it compares to "
+                    "Netallion AI Assurance."
+                ),
+                inputSchema={"type": "object", "properties": {}},
+            ),
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+        return _dispatch(name, arguments)
+
+    return server
+
+
+async def run_server() -> None:
+    server = create_server()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, server.create_initialization_options())
+
+
+def main() -> None:
+    import asyncio
+
+    asyncio.run(run_server())
+
+
+if __name__ == "__main__":
+    main()

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: netallion-mcp-lite
+Version: 0.1.0
+Summary: Free, local, IP-safe MCP server for AI-development security — commodity secret & credential checks from Netallion. Part of Agentic Development Governance.
+Author-email: Netallion <hello@netallion.ai>
+License: MIT
+Project-URL: Homepage, https://www.netallion.ai
+Project-URL: Documentation, https://www.netallion.ai
+Project-URL: Repository, https://github.com/netallion/netallion-mcp-lite
+Keywords: mcp,model-context-protocol,security,secrets,credentials,ai,agentic,governance,devsecops
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Dynamic: license-file
+
+# Netallion MCP Lite
+
+**Free, local, IP-safe AI-development security — an MCP server from Netallion.**
+
+Netallion MCP Lite is a small [Model Context Protocol](https://modelcontextprotocol.io) server that helps you and your AI coding assistants avoid the most common mistake in AI-assisted development: leaking a credential. It flags a curated set of **commodity, high-confidence** secrets and credentials (AWS, GitHub, Stripe, OpenAI, private keys, database URIs, and more) in text and files.
+
+It runs **entirely on your machine**. No account. No data sent to Netallion. Detected secrets are **redacted** before results are returned, so they are safe to hand back into an AI assistant's context.
+
+Part of Netallion's **Agentic Development Governance** approach — secret detection is one capability, not the whole story.
+
+---
+
+## What it is (and isn't)
+
+| | **Netallion MCP Lite** (this package) | **Netallion AI Assurance** (the platform) |
+|---|---|---|
+| Price | Free | Commercial (free trial) |
+| Runs | Locally, no account | SaaS + IDE + CI |
+| Detection | ~27 commodity, high-confidence checks | Advanced detection well beyond commodity patterns |
+| AI/MCP governance | — | AI provider governance, MCP governance |
+| Policy & visibility | — | Central policy management, org-wide visibility |
+| Compliance | — | Compliance and audit evidence |
+| Data | Nothing leaves your machine | Enterprise controls |
+
+MCP Lite is deliberately limited. It is a genuinely useful local utility **and** an on-ramp: if you want advanced detection, AI/MCP governance, central policy, and audit evidence across your organisation, that lives in **[Netallion AI Assurance](https://www.netallion.ai)**.
+
+This package does **not** contain or depend on Netallion's proprietary detection engine.
+
+---
+
+## Install & run
+
+Requires Python 3.10+.
+
+```bash
+pip install netallion-mcp-lite
+# or, zero-install:
+uvx netallion-mcp-lite
+```
+
+It speaks MCP over stdio. Add it to any MCP-compatible client (Claude, Cursor, Windsurf, VS Code, …):
+
+```json
+{
+  "mcpServers": {
+    "netallion-mcp-lite": {
+      "command": "netallion-mcp-lite"
+    }
+  }
+}
+```
+
+Optionally confine `scan_file` to a specific directory:
+
+```json
+{
+  "mcpServers": {
+    "netallion-mcp-lite": {
+      "command": "netallion-mcp-lite",
+      "env": { "NETALLION_MCP_LITE_WORKSPACE_ROOT": "/path/to/your/project" }
+    }
+  }
+}
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `scan_text` | Scan a string for commodity secrets; returns redacted findings (rule, severity, line/column, remediation). |
+| `scan_file` | Scan a file **inside the workspace root**; sensitive files (`.env`, keys) are refused; findings redacted. |
+| `list_supported_checks` | List the commodity checks (no secrets). |
+| `about` | About the tool, privacy posture, and Lite vs AI Assurance. |
+
+Run `list_supported_checks` to see the full set. Findings never include the full secret value.
+
+## Privacy
+
+Local-only. No telemetry. No source, file contents, prompts, or secrets are sent anywhere. See [PRIVACY.md](PRIVACY.md).
+
+## Scope & limitations
+
+- Commodity, high-confidence formats only — it will not catch obfuscated, encoded, or org-specific secrets. That is by design; advanced detection is part of Netallion AI Assurance.
+- `scan_file` reads only within a single workspace root and refuses obviously-sensitive files.
+- No generic high-entropy scanning (it produces noise without advanced technique).
+
+We make no claims about detection rates, false-positive rates, customer adoption, certifications, or regulatory compliance for this free utility.
+
+## Links
+
+- Netallion AI Assurance — https://www.netallion.ai
+- VS Code / Cursor / Windsurf extension — [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=netallion.netallion-ai-assurance) · [Open VSX](https://open-vsx.org/extension/netallion/netallion-ai-assurance)
+- Azure Marketplace — [Netallion AI Assurance](https://marketplace.microsoft.com/en-us/product/netallion.netallion-ai-assurance)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+MANIFEST.in
+PRIVACY.md
+README.md
+pyproject.toml
+src/netallion_mcp_lite/__init__.py
+src/netallion_mcp_lite/py.typed
+src/netallion_mcp_lite/redaction.py
+src/netallion_mcp_lite/rules.py
+src/netallion_mcp_lite/scanner.py
+src/netallion_mcp_lite/server.py
+src/netallion_mcp_lite.egg-info/PKG-INFO
+src/netallion_mcp_lite.egg-info/SOURCES.txt
+src/netallion_mcp_lite.egg-info/dependency_links.txt
+src/netallion_mcp_lite.egg-info/entry_points.txt
+src/netallion_mcp_lite.egg-info/requires.txt
+src/netallion_mcp_lite.egg-info/top_level.txt

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+netallion-mcp-lite = netallion_mcp_lite.server:main

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite.egg-info/requires.txt

@@ -0,0 +1 @@
+mcp>=1.0.0

netallion_mcp_lite-0.1.0/src/netallion_mcp_lite.egg-info/top_level.txt

@@ -0,0 +1 @@
+netallion_mcp_lite