tessen-cli 0.1.0__py3-none-any.whl

tessen/rules/builtin/secrets_in_env.py

@@ -0,0 +1,112 @@
+"""Detect plaintext secrets in MCP server environment variables."""
+
+from __future__ import annotations
+
+import re
+
+from tessen.models import ParseResult
+from tessen.rules.base import Rule
+from tessen.rules.models import Finding, RuleMetadata, Severity
+
+
+# Known secret prefixes/patterns from real-world providers.
+# Each entry: (pattern, provider_name, example)
+SECRET_PATTERNS: list[tuple[re.Pattern[str], str]] = [
+    (re.compile(r"^ghp_[A-Za-z0-9]{36,}$"), "GitHub Personal Access Token"),
+    (re.compile(r"^github_pat_[A-Za-z0-9_]{80,}$"), "GitHub Fine-Grained PAT"),
+    (re.compile(r"^gho_[A-Za-z0-9]{36,}$"), "GitHub OAuth Token"),
+    (re.compile(r"^sk-[A-Za-z0-9]{20,}$"), "OpenAI/Anthropic-style API key"),
+    (re.compile(r"^sk-ant-api03-[A-Za-z0-9_-]{80,}$"), "Anthropic API key"),
+    (re.compile(r"^AIza[A-Za-z0-9_-]{35}$"), "Google API key"),
+    (re.compile(r"^AKIA[A-Z0-9]{16}$"), "AWS Access Key ID"),
+    (re.compile(r"^xox[baprs]-[A-Za-z0-9-]{10,}$"), "Slack token"),
+    (re.compile(r"^lin_api_[A-Za-z0-9]{40,}$"), "Linear API key"),
+    (re.compile(r"^SG\.[A-Za-z0-9_-]{22}\.[A-Za-z0-9_-]{43}$"), "SendGrid API key"),
+]
+
+# Env var names that suggest a secret, even if the value doesn't match a known pattern.
+SUSPICIOUS_NAMES = re.compile(
+    r"(?i)(api[_-]?key|token|secret|password|passwd|auth|credential|private[_-]?key)"
+)
+
+# Values obviously safe (placeholders, references, empty).
+SAFE_VALUE_PATTERNS = [
+    re.compile(r"^\$\{.+\}$"),  # ${VAR_NAME} substitution
+    re.compile(r"^\$[A-Z_][A-Z0-9_]*$"),  # $VAR_NAME
+    re.compile(r"^<.*>$"),  # <YOUR_TOKEN>
+    re.compile(r"REDACTED|PLACEHOLDER|EXAMPLE|CHANGEME|TODO", re.IGNORECASE),
+]
+
+
+class SecretsInEnvRule(Rule):
+    METADATA = RuleMetadata(
+        id="tessen-secrets-in-env",
+        name="Plaintext secret in environment variable",
+        description=(
+            "MCP server configuration contains what appears to be a plaintext "
+            "credential (API key, token, or password) in an env var. Anyone with "
+            "read access to this config file can extract the secret."
+        ),
+        severity=Severity.CRITICAL,
+        references=[
+            "https://owasp.org/www-community/vulnerabilities/Insufficient_Session-ID_Length",
+            "https://docs.anthropic.com/en/docs/build-with-claude/mcp",
+        ],
+    )
+
+    def check(self, result: ParseResult) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for server_name, server in result.config.mcpServers.items():
+            for env_name, env_value in server.env.items():
+                if not env_value or self._is_safe_value(env_value):
+                    continue
+
+                matched_provider = self._match_known_pattern(env_value)
+                is_suspicious_name = bool(SUSPICIOUS_NAMES.search(env_name))
+
+                if matched_provider is None and not is_suspicious_name:
+                    continue
+
+                if matched_provider is not None:
+                    title = f"{matched_provider} exposed in plaintext"
+                    message = (
+                        f"The env var '{env_name}' in server '{server_name}' contains "
+                        f"a value matching a {matched_provider} pattern. Anyone reading "
+                        f"this config can use it."
+                    )
+                else:
+                    title = f"Possible secret in env var '{env_name}'"
+                    message = (
+                        f"The env var '{env_name}' in server '{server_name}' has a name "
+                        f"suggesting it holds a credential, and the value is not a "
+                        f"placeholder or variable reference."
+                    )
+
+                findings.append(
+                    Finding(
+                        rule_id=self.METADATA.id,
+                        severity=self.METADATA.severity,
+                        title=title,
+                        message=message,
+                        location=f"mcpServers.{server_name}.env.{env_name}",
+                        remediation=(
+                            "Move the secret to a secure store (1Password, Vault, "
+                            "or OS keychain) and reference it via ${VAR_NAME} substitution."
+                        ),
+                        references=self.METADATA.references,
+                    )
+                )
+
+        return findings
+
+    @staticmethod
+    def _is_safe_value(value: str) -> bool:
+        return any(p.search(value) for p in SAFE_VALUE_PATTERNS)
+
+    @staticmethod
+    def _match_known_pattern(value: str) -> str | None:
+        for pattern, provider in SECRET_PATTERNS:
+            if pattern.match(value):
+                return provider
+        return None

tessen/rules/builtin/suspicious_args.py

@@ -0,0 +1,91 @@
+"""Detect suspicious patterns in MCP server arguments."""
+
+from __future__ import annotations
+
+import unicodedata
+
+from tessen.models import ParseResult
+from tessen.rules.base import Rule
+from tessen.rules.models import Finding, RuleMetadata, Severity
+
+
+# Unicode categories associated with invisible / bidirectional / control text
+# that can hide malicious instructions.
+INVISIBLE_UNICODE_CATEGORIES = {"Cf", "Cc"}  # Format, Control
+
+
+# Args that grant filesystem-wide access.
+DANGEROUS_PATH_ARGS = {"/", "/etc", "/root", "/home", "~", "C:\\", "C:/"}
+
+
+class SuspiciousArgsRule(Rule):
+    METADATA = RuleMetadata(
+        id="tessen-suspicious-args",
+        name="Suspicious pattern in MCP server arguments",
+        description=(
+            "MCP server arguments contain hidden Unicode characters (potential prompt "
+            "injection carriers) or grant overly broad filesystem access."
+        ),
+        severity=Severity.HIGH,
+    )
+
+    def check(self, result: ParseResult) -> list[Finding]:
+        findings: list[Finding] = []
+
+        for server_name, server in result.config.mcpServers.items():
+            for i, arg in enumerate(server.args):
+                if hidden := self._find_invisible_unicode(arg):
+                    findings.append(
+                        Finding(
+                            rule_id=self.METADATA.id,
+                            severity=Severity.CRITICAL,
+                            title="Invisible Unicode in server argument",
+                            message=(
+                                f"Argument {i} of server '{server_name}' contains "
+                                f"{len(hidden)} invisible Unicode character(s): "
+                                f"{', '.join(hidden)}. These can hide instructions "
+                                f"that the agent will read as prompt input."
+                            ),
+                            location=f"mcpServers.{server_name}.args[{i}]",
+                            remediation=(
+                                "Inspect the argument character-by-character. Remove all "
+                                "characters in Unicode categories Cf (Format) and Cc (Control)."
+                            ),
+                            references=self.METADATA.references,
+                        )
+                    )
+
+                if arg.strip() in DANGEROUS_PATH_ARGS:
+                    findings.append(
+                        Finding(
+                            rule_id=self.METADATA.id,
+                            severity=Severity.HIGH,
+                            title="Server granted filesystem-wide access",
+                            message=(
+                                f"Argument {i} of server '{server_name}' is '{arg}', "
+                                f"granting the server access to the entire filesystem "
+                                f"or user home. Any prompt injection reaching this "
+                                f"server can read or modify sensitive files."
+                            ),
+                            location=f"mcpServers.{server_name}.args[{i}]",
+                            remediation=(
+                                "Scope the server to the minimum necessary directory. "
+                                "Prefer per-project paths over home or filesystem roots."
+                            ),
+                            references=self.METADATA.references,
+                        )
+                    )
+
+        return findings
+
+    @staticmethod
+    def _find_invisible_unicode(text: str) -> list[str]:
+        """Return a list of hex codepoints for invisible characters in text."""
+        hidden = []
+        for ch in text:
+            if unicodedata.category(ch) in INVISIBLE_UNICODE_CATEGORIES:
+                # Skip common whitespace controls (\t, \n) that aren't attacks.
+                if ch in ("\t", "\n", "\r"):
+                    continue
+                hidden.append(f"U+{ord(ch):04X}")
+        return hidden

tessen/rules/engine.py

@@ -0,0 +1,36 @@
+"""The rule engine — runs a set of rules against a ParseResult."""
+
+from __future__ import annotations
+
+from tessen.models import ParseResult
+from tessen.rules.base import Rule
+from tessen.rules.models import Finding
+
+
+class RuleEngine:
+    """Runs rules against parse results and collects findings."""
+
+    def __init__(self, rules: list[Rule]) -> None:
+        self.rules = rules
+
+    def run(self, result: ParseResult) -> list[Finding]:
+        """Run all rules against a single parse result. Returns sorted findings."""
+        findings: list[Finding] = []
+        for rule in self.rules:
+            try:
+                findings.extend(rule.check(result))
+            except Exception as e:
+                # A buggy rule should never crash the whole scan.
+                # Log and continue — but re-raise in dev mode later.
+                import warnings
+
+                warnings.warn(f"Rule '{rule.id}' raised {type(e).__name__}: {e}")
+                continue
+
+        # Sort: highest severity first, then by rule_id, then by location.
+        findings.sort(key=lambda f: (-f.severity.rank, f.rule_id, f.location))
+        return findings
+
+    def run_many(self, results: list[ParseResult]) -> dict[str, list[Finding]]:
+        """Run rules against multiple parse results. Keyed by source_path."""
+        return {str(r.source_path): self.run(r) for r in results}

tessen/rules/models.py

@@ -0,0 +1,52 @@
+"""Data models for detection rules and findings."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Severity(str, Enum):
+    """Finding severity levels."""
+
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+
+    @property
+    def rank(self) -> int:
+        """Numeric rank for sorting (higher = more severe)."""
+        return {"critical": 4, "high": 3, "medium": 2, "low": 1}[self.value]
+
+
+class Finding(BaseModel):
+    """A single security finding produced by a rule."""
+
+    model_config = ConfigDict(frozen=True)
+
+    rule_id: str = Field(..., description="Unique identifier of the rule that fired")
+    severity: Severity
+    title: str = Field(..., description="Short human-readable title")
+    message: str = Field(..., description="Detailed description of what was found")
+    location: str = Field(
+        ...,
+        description="Where in the config the issue lives (e.g. 'mcpServers.github.env.GITHUB_PAT')",
+    )
+    remediation: str | None = Field(None, description="How to fix it, in one sentence")
+    references: list[str] = Field(
+        default_factory=list, description="URLs to CVEs, advisories, or docs"
+    )
+
+
+class RuleMetadata(BaseModel):
+    """Metadata every rule must define."""
+
+    id: str = Field(
+        ..., pattern=r"^tessen-[a-z0-9-]+$", description="e.g. 'tessen-secrets-in-env'"
+    )
+    name: str
+    description: str
+    severity: Severity
+    references: list[str] = Field(default_factory=list)

tessen_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,301 @@
+Metadata-Version: 2.4
+Name: tessen-cli
+Version: 0.1.0
+Summary: Security scanner for AI agent configurations (MCP servers, Claude Desktop, Cursor, Claude Code, Windsurf).
+Keywords: security,scanner,mcp,ai-agents,claude,cursor,devsecops
+Author: Slim Ben Tanfous
+Author-email: Slim Ben Tanfous <slimbentanfous2002@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.26.7
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/SlimBenTanfous1/tessen-cli
+Project-URL: Repository, https://github.com/SlimBenTanfous1/tessen-cli
+Project-URL: Issues, https://github.com/SlimBenTanfous1/tessen-cli/issues
+Description-Content-Type: text/markdown
+
+# tessen
+
+![CI](https://github.com/SlimBenTanfous1/tessen-cli/actions/workflows/ci.yml/badge.svg)
+
+**Security scanner for AI agent configurations.**
+
+Tessen scans MCP (Model Context Protocol) configurations — the files that tell Claude Desktop, Claude Code, Cursor, and Windsurf which tools to load — for vulnerabilities that current tooling misses: plaintext credentials, dangerous invocation patterns, invisible Unicode instruction carriers, and filesystem-wide access grants.
+
+Point it at your config, get findings in seconds, wire it into CI to keep them from coming back.
+
+```
+tessen scan
+```
+
+> Named after the Japanese 鉄扇 (_tessen_), an iron war fan carried into places swords were forbidden. It looked like an ordinary fan. It was a weapon. So are the MCP servers hiding in your `claude_desktop_config.json`.
+
+---
+
+## Status
+
+**Alpha** (`v0.1.0`). The scanner works, the tests pass, but it hasn't been published to PyPI yet and the ruleset is small. Expect breaking changes to the rule format and CLI flags before `v0.2`. If you use it, run it locally, don't wire it into production CI yet.
+
+Current coverage: **3 built-in rules**, **3 client formats**, **26 tests**.
+
+---
+
+## What it catches
+
+Every finding includes a severity, location in the config, message explaining the issue, and a remediation suggestion.
+
+### `tessen-secrets-in-env` — plaintext credentials
+
+Detects API keys and tokens stored directly in MCP server environment variables. Recognizes patterns from GitHub (`ghp_`, `github_pat_`, `gho_`), Anthropic, OpenAI, AWS access keys, Google API keys, Slack tokens, Linear, and SendGrid. Distinguishes real secrets from environment variable references (`${VAR}`), placeholders (`<YOUR_KEY>`), and common redaction markers (`REDACTED`, `PLACEHOLDER`).
+
+**Severity:** `critical`
+
+### `tessen-dangerous-command` — shell wrappers and curl-pipe-shell
+
+Flags MCP servers invoked through a shell interpreter (`bash`, `sh`, `zsh`, `pwsh`, `cmd.exe`), which grants the server arbitrary command execution and makes any prompt injection catastrophic. Also detects `curl | sh`-style patterns that fetch and execute unverified remote code — a supply-chain risk that has produced multiple real-world incidents in 2025-2026.
+
+**Severity:** `high` (shell wrappers), `critical` (curl-pipe-shell)
+
+### `tessen-suspicious-args` — Unicode injection and overbroad scopes
+
+Two related detections. First, invisible Unicode characters (categories Cf and Cc — zero-width spaces, bidi overrides, format characters) in server arguments, which are the primary carrier for hidden prompt injection instructions. Second, filesystem-wide access grants like `/`, `/home`, or `~` passed to filesystem MCP servers.
+
+**Severity:** `critical` (invisible Unicode), `high` (filesystem grants)
+
+---
+
+## Install
+
+**From source (currently the only path):**
+
+```bash
+git clone https://github.com/SlimBenTanfous1/tessen-cli.git
+cd tessen-cli
+uv pip install -e .
+```
+
+Requires Python 3.11 or newer. Uses [uv](https://docs.astral.sh/uv/) as the package manager — install with `curl -LsSf https://astral.sh/uv/install.sh | sh`.
+
+**PyPI distribution is planned for `v0.2`.** Once published:
+
+```bash
+pipx install tessen  # coming soon
+```
+
+---
+
+## Usage
+
+### Auto-detect and scan everything
+
+```bash
+tessen scan
+```
+
+Walks the project tree upward from the current directory looking for `.mcp.json` (Claude Code) and `.cursor/mcp.json` (Cursor), then checks the OS-specific location for Claude Desktop (`~/.config/Claude/claude_desktop_config.json` on Linux, `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS, `%APPDATA%\Claude\claude_desktop_config.json` on Windows). Scans every config it finds.
+
+### Scan a specific file
+
+```bash
+tessen scan path/to/claude_desktop_config.json
+tessen scan .cursor/mcp.json --client cursor
+```
+
+The `--client` flag forces a specific parser when the filename doesn't match convention. Valid values: `claude_desktop`, `claude_code`, `cursor`.
+
+### Version
+
+```bash
+tessen version
+```
+
+---
+
+## CI integration
+
+Tessen exits non-zero when it finds issues at or above a severity threshold. This is the mechanism to keep vulnerable configs out of your `main` branch.
+
+```bash
+tessen scan --fail-on high
+```
+
+Exit codes: `0` for clean, `1` when the threshold is met, `2` for invalid flag values.
+
+Valid `--fail-on` values: `critical`, `high`, `medium`, `low`, `never`.
+
+**GitHub Actions example** (roughly — this pipeline hasn't been dogfooded yet):
+
+```yaml
+name: MCP Config Security
+
+on:
+  pull_request:
+    paths:
+      - ".mcp.json"
+      - ".cursor/mcp.json"
+      - ".claude/settings.json"
+
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install tessen
+        run: |
+          pip install git+https://github.com/SlimBenTanfous1/tessen-cli.git
+      - name: Scan MCP configs
+        run: tessen scan --fail-on high
+```
+
+---
+
+## Example output
+
+Scanning a config with three planted issues (real GitHub PAT, bash wrapper, filesystem-wide grant):
+
+```
+tessen scanning /path/to/claude_desktop_with_secrets.json
+
+Findings for Claude Desktop  1 critical · 2 high
+
+╭─ ● [CRITICAL] GitHub Personal Access Token exposed in plaintext ─────╮
+│ The env var 'GITHUB_PERSONAL_ACCESS_TOKEN' in server                 │
+│ 'github_real_leak' contains a value matching a GitHub Personal       │
+│ Access Token pattern.                                                │
+│                                                                      │
+│ Location:    mcpServers.github_real_leak.env.GITHUB_PERSONAL_...     │
+│ Rule:        tessen-secrets-in-env                                   │
+│ Remediation: Move the secret to a secure store (1Password, Vault,    │
+│              or OS keychain) and reference it via ${VAR_NAME}.       │
+╰──────────────────────────────────────────────────────────────────────╯
+
+Scan summary
+  Total findings: 3
+  Critical  1
+  High      2
+```
+
+---
+
+## Supported clients
+
+| Client         | Config path                                                                                                                                                                                   | Parser           |
+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
+| Claude Desktop | `~/.config/Claude/claude_desktop_config.json` (Linux)<br>`~/Library/Application Support/Claude/claude_desktop_config.json` (macOS)<br>`%APPDATA%\Claude\claude_desktop_config.json` (Windows) | `claude_desktop` |
+| Claude Code    | `<project>/.mcp.json`                                                                                                                                                                         | `claude_code`    |
+| Cursor         | `<project>/.cursor/mcp.json`                                                                                                                                                                  | `cursor`         |
+| Windsurf       | Planned for `v0.2`                                                                                                                                                                            | —                |
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/SlimBenTanfous1/tessen-cli.git
+cd tessen-cli
+uv sync                       # install runtime + dev deps
+source .venv/bin/activate     # or use `uv run <command>`
+
+# Run the test suite
+pytest tests/ -v
+
+# Run tessen against test fixtures
+tessen scan tests/fixtures/claude_desktop_with_secrets.json
+tessen scan tests/fixtures/claude_desktop_clean.json
+```
+
+### Project layout
+
+```
+tessen-cli/
+├── src/tessen/
+│   ├── cli.py                # Typer app: scan + version + --fail-on
+│   ├── models.py             # MCPConfig, ParseResult, ClientType
+│   ├── output/human.py       # Rich severity panels
+│   ├── parsers/
+│   │   ├── common.py         # Shared JSON+Pydantic parse logic
+│   │   ├── claude_desktop.py
+│   │   ├── claude_code.py    # + walker for .mcp.json
+│   │   ├── cursor.py         # + walker for .cursor/mcp.json
+│   │   └── auto.py           # Multi-client auto-detection
+│   └── rules/
+│       ├── base.py           # Rule ABC
+│       ├── engine.py         # RuleEngine with buggy-rule isolation
+│       ├── models.py         # Finding, Severity, RuleMetadata
+│       └── builtin/          # Built-in detection rules
+└── tests/                    # 26 tests, ~0.3s runtime
+```
+
+### Adding a rule
+
+1. Create `src/tessen/rules/builtin/your_rule.py`
+2. Subclass `Rule`, define `METADATA`, implement `check(result) -> list[Finding]`
+3. Register it in `src/tessen/rules/builtin/__init__.py` (`BUILTIN_RULES` list)
+4. Add tests in `tests/test_rules.py`
+
+Rules should be pure functions: no I/O, no state, no side effects. Same input → same output.
+
+---
+
+## Roadmap
+
+**`v0.1` (current) — foundation:** parsers for 3 clients, auto-detection, 3 detection rules, Rich terminal output, `--fail-on` for CI.
+
+**`v0.2` — coverage:**
+
+- 4 more rules: known-vulnerable MCP servers (CVE feed), HTTP transport without auth, dangerous auto-approve flags, hook injection in `.claude/settings.json`
+- JSON output format
+- SARIF output for GitHub Advanced Security compatibility
+- Windsurf parser
+- PyPI distribution (`pipx install tessen`)
+
+**`v0.3` — trust:**
+
+- GitHub Action for one-line CI integration
+- CVE feed as a subscribable JSON endpoint
+- First round of dogfooded findings on `awesome-mcp-servers`
+
+**Later:**
+
+- Custom rules via YAML
+- Baseline files (`.tessen-baseline`) to suppress known findings
+- Runtime hooks that observe tool calls at execution time
+
+Anything you want prioritized? Open an issue.
+
+---
+
+## Why "Tessen"
+
+A _tessen_ (鉄扇) is an iron folding fan carried by samurai as a concealed weapon into places where swords were forbidden — tea houses, temples, palaces. Ordinary-looking. Genuinely dangerous.
+
+Same shape as a poisoned MCP server: a small config file that looks like plumbing, and behaves like an attack.
+
+---
+
+## License
+
+MIT. See [LICENSE](./LICENSE).
+
+---
+
+## About
+
+Built by [Slim Ben Tanfous](https://github.com/SlimBenTanfous1) — cybersecurity engineer at BrightByDesign (Zero Trust infrastructure, CI/CD security), joining the ESGI Paris Master's in Cybersecurity in September 2026. Prior: CCNA, CyberOps Associate, AWS Cloud Security Foundations, OCI Foundations.
+
+Reach out: [github.com/SlimBenTanfous1](https://github.com/SlimBenTanfous1)

tessen_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+tessen/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+tessen/cli.py,sha256=twr0gG3wFMoYxNrRKsg9TK6WtU6yBwtrKY9cy8CFs9M,6232
+tessen/models.py,sha256=O4-k0WztABu1RiBRSiYKmd9P9iqVEw90i6T7b7MpzNs,1585
+tessen/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tessen/output/human.py,sha256=ncwCu6A1PMQMw_TF1zDqdFTSQ605ipoiIbzycMTrnjQ,3124
+tessen/output/json_output.py,sha256=HS63vBaJJ7G9AWVt9SUzze7vU0WRbL56XNB3wPd37GA,1749
+tessen/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tessen/parsers/auto.py,sha256=ZyOphBfhv84U1WngCeb0xZk47j2OCR3jPWXV2rC2BrY,2531
+tessen/parsers/claude_code.py,sha256=OMasF9UWLTs2bUbonWxvIIwbr5-iqktUyyfFtMgT7ug,1204
+tessen/parsers/claude_desktop.py,sha256=_hm3ysvEdCS3CcKdaf4hliLI_VjnfEj6-ZWowSHYVWo,651
+tessen/parsers/common.py,sha256=IlZqwjNhzATP7q7oIY9Z_2DgI_Y-JISaFB6nPW_lfhA,1903
+tessen/parsers/cursor.py,sha256=I-O13pDEmj-j-Pjrp648hQ0GVOsQWbhavv2FItn1h5Q,1036
+tessen/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tessen/rules/base.py,sha256=AppWQ7i9vuXupGAP4PCnYe7xUWnkvgHfMIPyke9ijd8,731
+tessen/rules/builtin/__init__.py,sha256=p2l4ZqjsRXUMGSaaSzWM3WcsPghkGLSMV6KoaoXM4Fk,942
+tessen/rules/builtin/auto_approve.py,sha256=Jm78ZwNcB0eVPQZCajRhqb7XK89F-_FZPv571CMgi6k,3588
+tessen/rules/builtin/dangerous_command.py,sha256=HfkIZSLcyubOe_5I75xKTONSqMWakqjpxsZZqWlIGDA,3929
+tessen/rules/builtin/hook_injection.py,sha256=1CyfD_7goLleLncrYb7nxyFEoPqqp0anuLmPv3gY5NU,6140
+tessen/rules/builtin/http_no_auth.py,sha256=vQq078OoLtzt2CdqerpZsmnYlk8A0RotIPLCJm7hLfM,3662
+tessen/rules/builtin/known_vulnerable.py,sha256=dzqofddutyP_t-gfm5_zy411tv92AYMtFOy9h72AD-c,6262
+tessen/rules/builtin/secrets_in_env.py,sha256=4c1MGiw5_UQ_kQarM6AxcZ353iGyGWE-sWlMRRjCDDU,4731
+tessen/rules/builtin/suspicious_args.py,sha256=zuSj4Avu4WxYA5qRPaBiStqjUSpd-xYh4wrx1drhW3E,4006
+tessen/rules/engine.py,sha256=zX2lrkSAh_VnmG2GODZ2OiJMUMlNcHaRnQ1TaLweu04,1380
+tessen/rules/models.py,sha256=yxFdHBz9LygFEtW_2mSVxB6XtIaVPhJ5M4_ru15PqCs,1543
+tessen_cli-0.1.0.dist-info/WHEEL,sha256=CoDSoyhtC_eO_tlxRYzsTraPv1fPJRXFx91k6ISeAvA,81
+tessen_cli-0.1.0.dist-info/entry_points.txt,sha256=nzc7tn52pnaj8uy1rKQNt8jsd1MNAG2-IczLpORxukg,43
+tessen_cli-0.1.0.dist-info/METADATA,sha256=zWCfQXBZawJdgmK4Ges1TYa59h0dBtujAeSth-lwzVk,12255
+tessen_cli-0.1.0.dist-info/RECORD,,

tessen_cli-0.1.0.dist-info/WHEEL

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

tessen_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+tessen = tessen.cli:app
+