free-claude-code 6.2.64__py3-none-any.whl

free_claude_code/runtime/retired_chat.py

@@ -0,0 +1,47 @@
+"""Remove saved data belonging to the retired Admin Chat Sessions feature."""
+
+from loguru import logger
+
+from free_claude_code.config import paths
+from free_claude_code.core.interprocess_lock import InterprocessFileLock
+
+
+def remove_retired_chat_history() -> None:
+    """Delete only owned history files, deferring failures to the next startup."""
+    try:
+        directory = paths.config_dir_path().resolve() / "chat"
+        try:
+            resolved = directory.resolve(strict=True)
+        except FileNotFoundError:
+            return
+        if resolved != directory:
+            logger.warning("Chat history cleanup deferred: redirected directory")
+            return
+        files = tuple(
+            directory / name
+            for name in ("chat.db", "chat.db-wal", "chat.db-shm", "chat.db-journal")
+        )
+        for path in files:
+            try:
+                path.lstat()
+            except FileNotFoundError:
+                continue
+            break
+        else:
+            return
+
+        lock = InterprocessFileLock(directory / "chat.lock")
+        try:
+            if not lock.acquire():
+                logger.warning("Chat history cleanup deferred: history is in use")
+                return
+            for path in files:
+                path.unlink(missing_ok=True)
+        finally:
+            # Keep the lock file: unlinking it could create two independent locks.
+            lock.release()
+    except OSError as exc:
+        logger.warning(
+            "Chat history cleanup deferred until next startup: exc_type={}",
+            type(exc).__name__,
+        )

free_claude_code/runtime/web_tools/__init__.py

@@ -0,0 +1 @@
+"""Outbound HTTP implementation for local web tools."""

free_claude_code/runtime/web_tools/client.py

@@ -0,0 +1,238 @@
+"""Outbound HTTP for web_search / web_fetch with operation-scoped resources."""
+
+import asyncio
+import socket
+from collections.abc import AsyncIterator
+from urllib.parse import urljoin, urlparse
+
+import aiohttp
+import httpx
+from aiohttp import ClientSession, ClientTimeout, TCPConnector
+from aiohttp.abc import AbstractResolver, ResolveResult
+
+from free_claude_code.application.web_tools.ports import (
+    WebFetchEgressPolicy,
+    WebFetchEgressViolation,
+)
+from free_claude_code.core.web_tools import WebFetchResult, WebSearchResult
+
+from . import constants
+from .constants import (
+    _MAX_FETCH_CHARS,
+    _MAX_SEARCH_RESULTS,
+    _REDIRECT_RESPONSE_BODY_CAP_BYTES,
+    _REQUEST_TIMEOUT_S,
+    _WEB_FETCH_REDIRECT_STATUSES,
+    _WEB_TOOL_HTTP_HEADERS,
+)
+from .egress import (
+    get_validated_stream_addrinfos_for_egress,
+)
+from .parsers import HTMLTextParser, SearchResultParser
+
+
+async def _iter_response_body_under_cap(
+    response: httpx.Response, max_bytes: int
+) -> AsyncIterator[bytes]:
+    if max_bytes <= 0:
+        return
+    received = 0
+    async for chunk in response.aiter_bytes(chunk_size=65_536):
+        if received >= max_bytes:
+            break
+        remaining = max_bytes - received
+        if len(chunk) <= remaining:
+            received += len(chunk)
+            yield chunk
+            if received >= max_bytes:
+                break
+        else:
+            yield chunk[:remaining]
+            break
+
+
+async def _drain_response_body_capped(response: httpx.Response, max_bytes: int) -> None:
+    async for _ in _iter_response_body_under_cap(response, max_bytes):
+        pass
+
+
+async def _read_response_body_capped(response: httpx.Response, max_bytes: int) -> bytes:
+    return b"".join(
+        [piece async for piece in _iter_response_body_under_cap(response, max_bytes)]
+    )
+
+
+_NUMERIC_RESOLVE_FLAGS = socket.AI_NUMERICHOST | socket.AI_NUMERICSERV
+_NAME_RESOLVE_FLAGS = socket.NI_NUMERICHOST | socket.NI_NUMERICSERV
+
+
+def getaddrinfo_rows_to_resolve_results(
+    host: str, addrinfos: list[tuple]
+) -> list[ResolveResult]:
+    """Map :func:`socket.getaddrinfo` rows to aiohttp :class:`ResolveResult` (ThreadedResolver logic)."""
+    out: list[ResolveResult] = []
+    for family, _type, proto, _canon, sockaddr in addrinfos:
+        if family == socket.AF_INET6:
+            if len(sockaddr) < 3:
+                continue
+            if sockaddr[3]:
+                resolved_host, port = socket.getnameinfo(sockaddr, _NAME_RESOLVE_FLAGS)
+            else:
+                resolved_host, port = sockaddr[:2]
+        else:
+            assert family == socket.AF_INET, family
+            resolved_host, port = sockaddr[0], sockaddr[1]
+            resolved_host = str(resolved_host)
+            port = int(port)
+        out.append(
+            ResolveResult(
+                hostname=host,
+                host=resolved_host,
+                port=int(port),
+                family=family,
+                proto=proto,
+                flags=_NUMERIC_RESOLVE_FLAGS,
+            )
+        )
+    return out
+
+
+class _PinnedEgressStaticResolver(AbstractResolver):
+    """Return only pre-validated :class:`ResolveResult` for the outbound request."""
+
+    def __init__(self, results: list[ResolveResult]) -> None:
+        self._results = results
+
+    async def resolve(
+        self, host: str, port: int = 0, family: int = socket.AF_INET
+    ) -> list[ResolveResult]:
+        return self._results
+
+    async def close(self) -> None:  # pragma: no cover - aiohttp contract
+        return
+
+
+async def _read_aiohttp_body_capped(
+    response: aiohttp.ClientResponse, max_bytes: int
+) -> bytes:
+    received = 0
+    parts: list[bytes] = []
+    async for chunk in response.content.iter_chunked(65_536):
+        if received >= max_bytes:
+            break
+        remaining = max_bytes - received
+        if len(chunk) <= remaining:
+            received += len(chunk)
+            parts.append(chunk)
+        else:
+            parts.append(chunk[:remaining])
+            break
+    return b"".join(parts)
+
+
+async def _drain_aiohttp_body_capped(
+    response: aiohttp.ClientResponse, max_bytes: int
+) -> None:
+    if max_bytes <= 0:
+        return
+    received = 0
+    async for chunk in response.content.iter_chunked(65_536):
+        received += len(chunk)
+        if received >= max_bytes:
+            break
+
+
+class HTTPWebToolsClient:
+    """Stateless adapter; each call owns its HTTP resources until completion."""
+
+    async def search(self, query: str) -> list[WebSearchResult]:
+        async with (
+            httpx.AsyncClient(
+                timeout=_REQUEST_TIMEOUT_S,
+                follow_redirects=True,
+                headers=_WEB_TOOL_HTTP_HEADERS,
+            ) as client,
+            client.stream(
+                "GET",
+                "https://lite.duckduckgo.com/lite/",
+                params={"q": query},
+            ) as response,
+        ):
+            response.raise_for_status()
+            body_bytes = await _read_response_body_capped(
+                response, constants._MAX_WEB_FETCH_RESPONSE_BYTES
+            )
+        text = body_bytes.decode("utf-8", errors="replace")
+        parser = SearchResultParser()
+        parser.feed(text)
+        return parser.results[:_MAX_SEARCH_RESULTS]
+
+    async def fetch(self, url: str, *, egress: WebFetchEgressPolicy) -> WebFetchResult:
+        """Fetch URL with manual redirects; each hop is DNS-pinned to validated addresses."""
+        current_url = url
+        redirect_hops = 0
+        timeout = ClientTimeout(total=_REQUEST_TIMEOUT_S)
+
+        while True:
+            addr_infos = await asyncio.to_thread(
+                get_validated_stream_addrinfos_for_egress, current_url, egress
+            )
+            host = urlparse(current_url).hostname or ""
+            results = getaddrinfo_rows_to_resolve_results(host, addr_infos)
+            resolver = _PinnedEgressStaticResolver(results)
+            connector = TCPConnector(
+                resolver=resolver,
+                force_close=True,
+            )
+            try:
+                async with (
+                    ClientSession(
+                        timeout=timeout,
+                        headers=_WEB_TOOL_HTTP_HEADERS,
+                        connector=connector,
+                    ) as session,
+                    session.get(current_url, allow_redirects=False) as response,
+                ):
+                    if response.status in _WEB_FETCH_REDIRECT_STATUSES:
+                        await _drain_aiohttp_body_capped(
+                            response, _REDIRECT_RESPONSE_BODY_CAP_BYTES
+                        )
+                        if redirect_hops >= constants._MAX_WEB_FETCH_REDIRECTS:
+                            raise WebFetchEgressViolation(
+                                "web_fetch exceeded maximum redirects "
+                                f"({constants._MAX_WEB_FETCH_REDIRECTS})"
+                            )
+                        location = response.headers.get("location")
+                        if not location or not location.strip():
+                            raise WebFetchEgressViolation(
+                                "web_fetch redirect response missing Location header"
+                            )
+                        current_url = urljoin(str(response.url), location.strip())
+                        redirect_hops += 1
+                        continue
+                    response.raise_for_status()
+                    content_type = response.headers.get("content-type", "text/plain")
+                    final_url = str(response.url)
+                    encoding = response.get_encoding() or "utf-8"
+                    body_bytes = await _read_aiohttp_body_capped(
+                        response, constants._MAX_WEB_FETCH_RESPONSE_BYTES
+                    )
+            finally:
+                await connector.close()
+
+            break
+
+        text = body_bytes.decode(encoding, errors="replace")
+        title = final_url
+        data = text
+        if "html" in content_type.lower():
+            parser = HTMLTextParser()
+            parser.feed(text)
+            title = parser.title or final_url
+            data = "\n".join(parser.text_parts)
+        return WebFetchResult(
+            url=final_url,
+            title=title,
+            media_type="text/plain",
+            data=data[:_MAX_FETCH_CHARS],
+        )

free_claude_code/runtime/web_tools/constants.py

@@ -0,0 +1,17 @@
+"""Limits and defaults for outbound web server tool HTTP."""
+
+from free_claude_code.core.version import package_version
+
+_REQUEST_TIMEOUT_S = 20.0
+_MAX_SEARCH_RESULTS = 10
+_MAX_FETCH_CHARS = 24_000
+# Hard cap on raw bytes read from HTTP responses before decode / HTML parse (memory bound).
+_MAX_WEB_FETCH_RESPONSE_BYTES = 2 * 1024 * 1024
+# Drain at most this many bytes from redirect responses before following Location.
+_REDIRECT_RESPONSE_BODY_CAP_BYTES = 65_536
+_MAX_WEB_FETCH_REDIRECTS = 10
+_WEB_FETCH_REDIRECT_STATUSES = frozenset({301, 302, 303, 307, 308})
+
+_WEB_TOOL_HTTP_HEADERS = {
+    "User-Agent": f"Mozilla/5.0 compatible; free-claude-code/{package_version()}",
+}

free_claude_code/runtime/web_tools/egress.py

@@ -0,0 +1,89 @@
+"""Egress policy for user-controlled web_fetch URLs (SSRF guard)."""
+
+import ipaddress
+import socket
+from urllib.parse import urlparse
+
+from free_claude_code.application.web_tools.ports import (
+    WebFetchEgressPolicy,
+    WebFetchEgressViolation,
+)
+
+
+def _port_for_url(parsed) -> int:
+    if parsed.port is not None:
+        return parsed.port
+    return 443 if (parsed.scheme or "").lower() == "https" else 80
+
+
+def _stream_getaddrinfo_or_raise(host: str, port: int) -> list[tuple]:
+    try:
+        return socket.getaddrinfo(
+            host, port, type=socket.SOCK_STREAM, proto=socket.IPPROTO_TCP
+        )
+    except OSError as exc:
+        raise WebFetchEgressViolation(
+            f"Could not resolve host {host!r}: {exc}"
+        ) from exc
+
+
+def get_validated_stream_addrinfos_for_egress(
+    url: str, policy: WebFetchEgressPolicy
+) -> list[tuple]:
+    """Resolve and validate a URL for web_fetch, returning getaddrinfo rows for pinning.
+
+    Each HTTP connect pins to only these `getaddrinfo` results so a malicious DNS
+    server cannot rebind to a disallowed address between resolution and the TCP
+    connect (used by :meth:`runtime.web_tools.client.HTTPWebToolsClient.fetch`).
+    """
+    parsed = urlparse(url)
+    scheme = (parsed.scheme or "").lower()
+    if scheme not in policy.allowed_schemes:
+        raise WebFetchEgressViolation(
+            f"URL scheme {scheme!r} is not allowed for web_fetch"
+        )
+
+    host = parsed.hostname
+    if host is None or host == "":
+        raise WebFetchEgressViolation("web_fetch URL must include a host")
+
+    port = _port_for_url(parsed)
+
+    if policy.allow_private_network_targets:
+        return _stream_getaddrinfo_or_raise(host, port)
+
+    host_lower = host.lower()
+    if host_lower == "localhost" or host_lower.endswith(".localhost"):
+        raise WebFetchEgressViolation("localhost targets are not allowed for web_fetch")
+    if host_lower.endswith(".local"):
+        raise WebFetchEgressViolation(".local hostnames are not allowed for web_fetch")
+
+    try:
+        parsed_ip = ipaddress.ip_address(host)
+    except ValueError:
+        parsed_ip = None
+
+    if parsed_ip is not None:
+        if not parsed_ip.is_global:
+            raise WebFetchEgressViolation(
+                f"Non-public IP host {host!r} is not allowed for web_fetch"
+            )
+        return _stream_getaddrinfo_or_raise(host, port)
+
+    infos = _stream_getaddrinfo_or_raise(host, port)
+    for *_, sockaddr in infos:
+        addr = sockaddr[0]
+        try:
+            resolved = ipaddress.ip_address(addr)
+        except ValueError:
+            continue
+        if not resolved.is_global:
+            raise WebFetchEgressViolation(
+                f"Host {host!r} resolves to a non-public address ({resolved})"
+            )
+    return infos
+
+
+def enforce_web_fetch_egress(url: str, policy: WebFetchEgressPolicy) -> None:
+    """Validate ``url`` (scheme, host, and resolved addresses) for web_fetch."""
+    get_validated_stream_addrinfos_for_egress(url, policy)

free_claude_code/runtime/web_tools/parsers.py

@@ -0,0 +1,78 @@
+"""HTML parsing for web_search / web_fetch."""
+
+import html
+from html.parser import HTMLParser
+from urllib.parse import parse_qs, unquote, urlparse
+
+from free_claude_code.core.web_tools import WebSearchResult
+
+
+class SearchResultParser(HTMLParser):
+    """DuckDuckGo lite HTML: extract result links and titles."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.results: list[WebSearchResult] = []
+        self._href: str | None = None
+        self._title_parts: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag != "a":
+            return
+        href = dict(attrs).get("href")
+        if not href or "uddg=" not in href:
+            return
+        parsed = urlparse(href)
+        query = parse_qs(parsed.query)
+        uddg = query.get("uddg", [""])[0]
+        if not uddg:
+            return
+        self._href = unquote(uddg)
+        self._title_parts = []
+
+    def handle_data(self, data: str) -> None:
+        if self._href is not None:
+            self._title_parts.append(data)
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag != "a" or self._href is None:
+            return
+        title = " ".join("".join(self._title_parts).split())
+        if title and not any(result.url == self._href for result in self.results):
+            self.results.append(
+                WebSearchResult(title=html.unescape(title), url=self._href)
+            )
+        self._href = None
+        self._title_parts = []
+
+
+class HTMLTextParser(HTMLParser):
+    """Strip scripts/styles and collect visible text + title for fetch previews."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.title = ""
+        self.text_parts: list[str] = []
+        self._in_title = False
+        self._skip_depth = 0
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag in {"script", "style", "noscript"}:
+            self._skip_depth += 1
+        elif tag == "title":
+            self._in_title = True
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in {"script", "style", "noscript"} and self._skip_depth:
+            self._skip_depth -= 1
+        elif tag == "title":
+            self._in_title = False
+
+    def handle_data(self, data: str) -> None:
+        text = " ".join(data.split())
+        if not text:
+            return
+        if self._in_title:
+            self.title = f"{self.title} {text}".strip()
+        elif not self._skip_depth:
+            self.text_parts.append(text)

free_claude_code-6.2.64.data/scripts/fcc-update

@@ -0,0 +1,4 @@
+#!/bin/sh
+set -eu
+installer=$(curl -fsSL "https://raw.githubusercontent.com/Alishahryar1/free-claude-code/main/scripts/install.sh")
+exec sh -c "$installer" sh "$@"

free_claude_code-6.2.64.data/scripts/fcc-update.cmd

@@ -0,0 +1,5 @@
+@echo off
+(
+  powershell.exe -NoProfile -ExecutionPolicy Bypass -Command "$ErrorActionPreference = 'Stop'; & ([scriptblock]::Create((Invoke-RestMethod 'https://raw.githubusercontent.com/Alishahryar1/free-claude-code/main/scripts/install.ps1')))" %*
+  call exit /b %%errorlevel%%
+)