pentool 1.0.0__py3-none-any.whl

pentool/core/storage_interface.py

@@ -0,0 +1,311 @@
+"""Storage Interface — abstraction layer for database operations.
+
+This interface allows switching between SQLite (desktop) and PostgreSQL (SaaS)
+without changing business logic.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class StorageInterface(ABC):
+    """Abstract base class for storage implementations.
+
+    Implementations:
+    - SQLiteStorage (current, for desktop)
+    - PostgreSQLStorage (future, for SaaS)
+    """
+
+    @abstractmethod
+    async def init_db(self, path_or_conn_string: str) -> None:
+        """Initialize database connection.
+
+        Args:
+            path_or_conn_string: File path for SQLite, connection string for PostgreSQL
+        """
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close database connection."""
+        pass
+
+    # ── HTTP History operations ────────────────────────────────────────────────
+
+    @abstractmethod
+    async def add_request(
+        self,
+        method: str,
+        url: str,
+        status_code: int | None,
+        request_headers: dict[str, str] | None,
+        response_headers: dict[str, str] | None,
+        request_body: str | None,
+        response_body: str | None,
+        **kwargs,
+    ) -> int:
+        """Add HTTP request/response pair to storage.
+
+        Returns:
+            Row ID of inserted record
+        """
+        pass
+
+    @abstractmethod
+    async def get_request(self, row_id: int) -> dict[str, Any] | None:
+        """Get HTTP request/response by ID."""
+        pass
+
+    @abstractmethod
+    async def get_requests(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        order_by: str = "timestamp DESC",
+    ) -> list[dict[str, Any]]:
+        """Get list of HTTP requests with filtering and pagination."""
+        pass
+
+    @abstractmethod
+    async def update_response(
+        self,
+        row_id: int,
+        status_code: int,
+        response_headers: dict[str, str],
+        response_body: str,
+    ) -> None:
+        """Update response data for existing request."""
+        pass
+
+    @abstractmethod
+    async def delete_request(self, row_id: int) -> None:
+        """Delete HTTP request by ID."""
+        pass
+
+    @abstractmethod
+    async def clear_all_requests(self) -> None:
+        """Delete all HTTP requests."""
+        pass
+
+    @abstractmethod
+    async def search_requests(self, query: str, limit: int = 100) -> list[dict[str, Any]]:
+        """Full-text search in requests (FTS5 for SQLite, tsvector for PostgreSQL)."""
+        pass
+
+    # ── Scanner findings operations ────────────────────────────────────────────
+
+    @abstractmethod
+    async def add_finding(
+        self,
+        severity: str,
+        title: str,
+        url: str,
+        description: str,
+        evidence: str | None,
+        **kwargs,
+    ) -> int:
+        """Add vulnerability finding to storage."""
+        pass
+
+    @abstractmethod
+    async def get_findings(
+        self,
+        limit: int = 100,
+        filters: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Get list of findings with filtering."""
+        pass
+
+    @abstractmethod
+    async def update_finding(self, finding_id: int, **kwargs) -> None:
+        """Update finding (e.g., mark as false positive)."""
+        pass
+
+    @abstractmethod
+    async def delete_finding(self, finding_id: int) -> None:
+        """Delete finding."""
+        pass
+
+    @abstractmethod
+    async def clear_all_findings(self) -> None:
+        """Delete all findings."""
+        pass
+
+    # ── Project/session metadata ───────────────────────────────────────────────
+
+    @abstractmethod
+    async def get_metadata(self, key: str) -> Any | None:
+        """Get project metadata by key."""
+        pass
+
+    @abstractmethod
+    async def set_metadata(self, key: str, value: Any) -> None:
+        """Set project metadata."""
+        pass
+
+    # ── Statistics ─────────────────────────────────────────────────────────────
+
+    @abstractmethod
+    async def get_stats(self) -> dict[str, Any]:
+        """Get storage statistics (counts, sizes, etc.)."""
+        pass
+
+
+class SQLiteStorage(StorageInterface):
+    """SQLite implementation (current desktop version).
+
+    This is a thin wrapper around existing HttpStorage for compatibility.
+    """
+
+    def __init__(self) -> None:
+        from pentool.storage.http_storage import HttpStorage
+        self._storage = HttpStorage()
+
+    async def init_db(self, path_or_conn_string: str) -> None:
+        await self._storage.init_db(path_or_conn_string)
+
+    async def close(self) -> None:
+        await self._storage.close()
+
+    async def add_request(
+        self,
+        method: str,
+        url: str,
+        status_code: int | None,
+        request_headers: dict[str, str] | None,
+        response_headers: dict[str, str] | None,
+        request_body: str | None,
+        response_body: str | None,
+        **kwargs,
+    ) -> int:
+        # Delegate to existing HttpStorage implementation
+        from pentool.utils.parser import ParsedRequest, ParsedResponse
+
+        req = ParsedRequest(
+            method=method,
+            url=url,
+            headers=request_headers or {},
+            body=request_body or "",
+        )
+
+        resp = ParsedResponse(
+            status=status_code or 0,
+            headers=response_headers or {},
+            body=response_body or "",
+        ) if status_code else None
+
+        return await self._storage.add_request(req, resp)
+
+    async def get_request(self, row_id: int) -> dict[str, Any] | None:
+        return await self._storage.get_request_by_id(row_id)
+
+    async def get_requests(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        order_by: str = "timestamp DESC",
+    ) -> list[dict[str, Any]]:
+        return await self._storage.get_requests_metadata(
+            limit=limit,
+            offset=offset,
+            order_by=order_by,
+        )
+
+    async def update_response(
+        self,
+        row_id: int,
+        status_code: int,
+        response_headers: dict[str, str],
+        response_body: str,
+    ) -> None:
+        await self._storage.update_response(
+            row_id,
+            status_code,
+            response_headers,
+            response_body,
+        )
+
+    async def delete_request(self, row_id: int) -> None:
+        await self._storage.delete_request(row_id)
+
+    async def clear_all_requests(self) -> None:
+        await self._storage.clear_all()
+
+    async def search_requests(self, query: str, limit: int = 100) -> list[dict[str, Any]]:
+        return await self._storage.search(query, limit=limit)
+
+    # Scanner findings (delegating to database.py)
+    async def add_finding(
+        self,
+        severity: str,
+        title: str,
+        url: str,
+        description: str,
+        evidence: str | None,
+        **kwargs,
+    ) -> int:
+        # TODO: implement via core/database.py
+        raise NotImplementedError("Findings storage not yet migrated to interface")
+
+    async def get_findings(
+        self,
+        limit: int = 100,
+        filters: dict[str, Any] | None = None,
+    ) -> list[dict[str, Any]]:
+        raise NotImplementedError("Findings storage not yet migrated to interface")
+
+    async def update_finding(self, finding_id: int, **kwargs) -> None:
+        raise NotImplementedError("Findings storage not yet migrated to interface")
+
+    async def delete_finding(self, finding_id: int) -> None:
+        raise NotImplementedError("Findings storage not yet migrated to interface")
+
+    async def clear_all_findings(self) -> None:
+        raise NotImplementedError("Findings storage not yet migrated to interface")
+
+    async def get_metadata(self, key: str) -> Any | None:
+        raise NotImplementedError("Metadata storage not yet implemented")
+
+    async def set_metadata(self, key: str, value: Any) -> None:
+        raise NotImplementedError("Metadata storage not yet implemented")
+
+    async def get_stats(self) -> dict[str, Any]:
+        # Return basic stats from HttpStorage
+        return {
+            "total_requests": await self._storage.count(),
+            "total_findings": 0,  # TODO
+        }
+
+
+# Future: PostgreSQLStorage for SaaS
+# class PostgreSQLStorage(StorageInterface):
+#     """PostgreSQL implementation for SaaS version."""
+#     pass
+
+
+def create_storage(backend: str = "sqlite") -> StorageInterface:
+    """Factory function to create storage instance.
+
+    Args:
+        backend: "sqlite" or "postgresql"
+
+    Returns:
+        StorageInterface implementation
+    """
+    if backend == "sqlite":
+        return SQLiteStorage()
+    elif backend == "postgresql":
+        raise NotImplementedError("PostgreSQL storage not yet implemented")
+    else:
+        raise ValueError(f"Unknown storage backend: {backend}")
+
+
+__all__ = [
+    "StorageInterface",
+    "SQLiteStorage",
+    "create_storage",
+]

pentool/core/updater.py

@@ -0,0 +1,96 @@
+"""Update checker — checks GitHub releases for a newer version."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass
+class UpdateInfo:
+    has_update: bool
+    latest_version: str
+    url: str
+    error: str = ""
+
+
+def _parse_version(v: str) -> tuple[int, ...]:
+    """Parse 'v1.2.3' or '1.2.3' into (1, 2, 3)."""
+    v = v.lstrip("v").strip()
+    try:
+        return tuple(int(x) for x in v.split(".")[:3])
+    except Exception:
+        return (0,)
+
+
+async def check_update_async(
+    owner: str = "sudores",
+    repo: str = "pentool",
+    timeout: float = 6.0,
+) -> UpdateInfo:
+    """Query GitHub releases API and compare with installed version."""
+    try:
+        from pentool import __version__ as current_version
+    except Exception:
+        current_version = "0.0.0"
+
+    url = f"https://api.github.com/repos/{owner}/{repo}/releases/latest"
+
+    try:
+        import aiohttp  # type: ignore[import]
+    except ImportError:
+        return UpdateInfo(has_update=False, latest_version=current_version, url="",
+                          error="aiohttp not installed")
+
+    try:
+        aio_timeout = aiohttp.ClientTimeout(total=timeout)
+        async with aiohttp.ClientSession(timeout=aio_timeout) as session:
+            async with session.get(
+                url,
+                headers={"Accept": "application/vnd.github+json"},
+                ssl=False,
+            ) as resp:
+                if resp.status != 200:
+                    return UpdateInfo(has_update=False, latest_version=current_version,
+                                      url="", error=f"HTTP {resp.status}")
+                data = await resp.json()
+    except asyncio.TimeoutError:
+        return UpdateInfo(has_update=False, latest_version=current_version,
+                          url="", error="timeout")
+    except Exception as exc:
+        return UpdateInfo(has_update=False, latest_version=current_version,
+                          url="", error=str(exc))
+
+    latest_tag = data.get("tag_name", "")
+    html_url   = data.get("html_url", "")
+    if not latest_tag:
+        return UpdateInfo(has_update=False, latest_version=current_version,
+                          url="", error="no tag_name in response")
+
+    has_update = _parse_version(latest_tag) > _parse_version(current_version)
+    return UpdateInfo(has_update=has_update, latest_version=latest_tag, url=html_url)
+
+
+def check_update_sync() -> UpdateInfo:
+    """Synchronous wrapper for use outside an async context."""
+    try:
+        loop = asyncio.new_event_loop()
+        result = loop.run_until_complete(check_update_async())
+        loop.close()
+        return result
+    except Exception as exc:
+        return UpdateInfo(has_update=False, latest_version="", url="", error=str(exc))
+
+
+def do_pip_upgrade() -> bool:
+    """Attempt to upgrade via pip. Returns True on success."""
+    import subprocess, sys
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "pentool"],
+            capture_output=True, text=True, timeout=120,
+        )
+        return result.returncode == 0
+    except Exception:
+        return False

pentool/core/utils.py

@@ -0,0 +1,61 @@
+"""core/utils.py — утилиты общего назначения.
+
+Содержит функции, которые нужны нескольким слоям приложения,
+но не принадлежат ни одному конкретному модулю.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import Any, Coroutine, TypeVar
+
+T = TypeVar("T")
+
+
+def run_async_sync(coro: Coroutine[Any, Any, T], timeout: float = 15.0) -> T:
+    """Запустить async-корутину из синхронного контекста.
+
+    Создаёт новый event loop в отдельном daemon-треде, дожидается
+    результата с таймаутом и возвращает его.
+
+    Используется когда нужно вызвать async-функцию из sync-кода
+    (например, из export_project_data, import_project_data и т.п.)
+    и при этом нельзя использовать asyncio.run() (т.к. внешний loop
+    уже работает — Textual TUI loop).
+
+    Args:
+        coro:    Async-корутина для выполнения.
+        timeout: Максимальное время ожидания в секундах (default=15).
+
+    Returns:
+        Результат корутины.
+
+    Raises:
+        TimeoutError: Если корутина не завершилась за timeout секунд.
+        Exception:    Любое исключение из корутины пробрасывается наружу.
+    """
+    result: list[Any] = []
+    exc_box: list[BaseException] = []
+    done_event = threading.Event()
+
+    def _run() -> None:
+        loop = asyncio.new_event_loop()
+        try:
+            result.append(loop.run_until_complete(coro))
+        except Exception as e:
+            exc_box.append(e)
+        finally:
+            loop.close()
+            done_event.set()
+
+    threading.Thread(target=_run, daemon=True).start()
+    finished = done_event.wait(timeout=timeout)
+    if not finished:
+        raise TimeoutError(f"run_async_sync: timed out after {timeout}s")
+    if exc_box:
+        raise exc_box[0]
+    return result[0] if result else None  # type: ignore[return-value]
+
+
+__all__ = ["run_async_sync"]

pentool/modules/__init__.py

@@ -0,0 +1 @@
+"""Пакет modules: логика модулей, независимая от интерфейса."""

pentool/modules/comparer.py

@@ -0,0 +1,177 @@
+"""Comparer — side-by-side diff двух текстов с подсветкой различий."""
+
+from __future__ import annotations
+
+import difflib
+from dataclasses import dataclass
+
+__all__ = ["compare", "compare_lines", "CompareStats", "DiffLine", "DiffResult"]
+
+
+@dataclass
+class DiffLine:
+    """Одна строка diff-результата."""
+
+    tag: str           # "equal" | "replace" | "insert" | "delete"
+    left: str          # текст левой стороны (пустая если insert)
+    right: str         # текст правой стороны (пустая если delete)
+    line_left: int     # номер строки слева (0 если нет)
+    line_right: int    # номер строки справа (0 если нет)
+
+
+@dataclass
+class CompareStats:
+    """Статистика сравнения."""
+
+    total_left: int
+    total_right: int
+    equal_lines: int
+    added_lines: int
+    removed_lines: int
+    changed_lines: int
+    similarity: float  # 0.0–1.0
+
+    @property
+    def similarity_pct(self) -> int:
+        return int(self.similarity * 100)
+
+
+@dataclass
+class DiffResult:
+    """Результат сравнения: строки diff + статистика."""
+
+    lines: list[DiffLine]
+    stats: CompareStats
+
+    def rich_text(self) -> str:
+        """Собрать Rich-markup строку для RichLog."""
+        parts: list[str] = []
+        for dl in self.lines:
+            if dl.tag == "equal":
+                parts.append(f"[dim]  {dl.left}[/dim]")
+            elif dl.tag == "insert":
+                parts.append(f"[green]+ {dl.right}[/green]")
+            elif dl.tag == "delete":
+                parts.append(f"[red]- {dl.left}[/red]")
+            elif dl.tag == "replace":
+                parts.append(f"[red]- {dl.left}[/red]")
+                parts.append(f"[green]+ {dl.right}[/green]")
+        return "\n".join(parts)
+
+
+def compare(left: str, right: str) -> DiffResult:
+    """Сравнить два текста построчно.
+
+    Args:
+        left: Левый текст.
+        right: Правый текст.
+
+    Returns:
+        DiffResult с построчными различиями и статистикой.
+    """
+    left_lines = left.splitlines()
+    right_lines = right.splitlines()
+    return compare_lines(left_lines, right_lines)
+
+
+def compare_lines(left_lines: list[str], right_lines: list[str]) -> DiffResult:
+    """Сравнить два списка строк.
+
+    Args:
+        left_lines: Строки левой стороны.
+        right_lines: Строки правой стороны.
+
+    Returns:
+        DiffResult с построчными различиями и статистикой.
+    """
+    matcher = difflib.SequenceMatcher(None, left_lines, right_lines, autojunk=False)
+    opcodes = matcher.get_opcodes()
+
+    diff_lines: list[DiffLine] = []
+    equal = added = removed = changed = 0
+
+    ln_left = 1
+    ln_right = 1
+
+    for tag, i1, i2, j1, j2 in opcodes:
+        if tag == "equal":
+            for k in range(i2 - i1):
+                diff_lines.append(DiffLine(
+                    tag="equal",
+                    left=left_lines[i1 + k],
+                    right=right_lines[j1 + k],
+                    line_left=ln_left + k,
+                    line_right=ln_right + k,
+                ))
+            equal += i2 - i1
+            ln_left += i2 - i1
+            ln_right += j2 - j1
+
+        elif tag == "replace":
+            # Показываем удалённые строки слева, добавленные справа
+            left_chunk = left_lines[i1:i2]
+            right_chunk = right_lines[j1:j2]
+            max_len = max(len(left_chunk), len(right_chunk))
+            for k in range(max_len):
+                l_text = left_chunk[k] if k < len(left_chunk) else ""
+                r_text = right_chunk[k] if k < len(right_chunk) else ""
+                if l_text and r_text:
+                    diff_lines.append(DiffLine(
+                        tag="replace",
+                        left=l_text, right=r_text,
+                        line_left=ln_left + k if k < len(left_chunk) else 0,
+                        line_right=ln_right + k if k < len(right_chunk) else 0,
+                    ))
+                elif l_text:
+                    diff_lines.append(DiffLine(
+                        tag="delete", left=l_text, right="",
+                        line_left=ln_left + k, line_right=0,
+                    ))
+                else:
+                    diff_lines.append(DiffLine(
+                        tag="insert", left="", right=r_text,
+                        line_left=0, line_right=ln_right + k,
+                    ))
+            changed += max(len(left_chunk), len(right_chunk))
+            ln_left += i2 - i1
+            ln_right += j2 - j1
+
+        elif tag == "delete":
+            for k in range(i2 - i1):
+                diff_lines.append(DiffLine(
+                    tag="delete",
+                    left=left_lines[i1 + k], right="",
+                    line_left=ln_left + k, line_right=0,
+                ))
+            removed += i2 - i1
+            ln_left += i2 - i1
+
+        elif tag == "insert":
+            for k in range(j2 - j1):
+                diff_lines.append(DiffLine(
+                    tag="insert",
+                    left="", right=right_lines[j1 + k],
+                    line_left=0, line_right=ln_right + k,
+                ))
+            added += j2 - j1
+            ln_right += j2 - j1
+
+    similarity = matcher.ratio()
+    stats = CompareStats(
+        total_left=len(left_lines),
+        total_right=len(right_lines),
+        equal_lines=equal,
+        added_lines=added,
+        removed_lines=removed,
+        changed_lines=changed,
+        similarity=similarity,
+    )
+    return DiffResult(lines=diff_lines, stats=stats)
+
+
+def compare_bytes(left: bytes, right: bytes) -> DiffResult:
+    """Сравнить два байтовых потока (декодируются как UTF-8 с заменой)."""
+    return compare(
+        left.decode("utf-8", errors="replace"),
+        right.decode("utf-8", errors="replace"),
+    )