router-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{router_cli-0.2.0 → router_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: router-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: CLI tool to manage D-Link DSL-2750U router
 Keywords: router,cli,dlink,dsl-2750u,network,admin
 Author: d3vr
@@ -40,7 +40,7 @@ Since the router doesn't provide a formal API, this tool works by authenticating
 
 ## Installation
 
-Requires Python 3.11 or higher.
+Requires Python 3.10 or higher.
 
 ### Using uv (recommended)
 
@@ -88,6 +88,24 @@ The tool searches for configuration in the following locations (in order):
 
 ## Usage
 
+### Global Options
+
+All commands support these global options:
+
+```bash
+router --ip 192.168.1.1 --user admin --pass secret status
+router --json clients
+```
+
+| Option | Environment Variable | Description |
+|--------|---------------------|-------------|
+| `--ip ADDRESS` | `ROUTER_IP` | Router IP address |
+| `--user USERNAME` | `ROUTER_USER` | Username for authentication |
+| `--pass PASSWORD` | `ROUTER_PASS` | Password for authentication |
+| `--json` | - | Output in JSON format (for scripting) |
+
+**Configuration priority**: CLI flags > environment variables > config file > defaults
+
 ### Quick Overview
 
 ```bash
@@ -242,7 +260,7 @@ uv run pytest
 
 ## Compatibility
 
-- **Python**: 3.11+
+- **Python**: 3.10+
 - **Router**: D-Link DSL-2750U (firmware ME_1.00)
 
 This tool may work with other D-Link routers that share a similar web interface, but has only been tested with the DSL-2750U.

{router_cli-0.2.0 → router_cli-0.3.0}/README.md

@@ -15,7 +15,7 @@ Since the router doesn't provide a formal API, this tool works by authenticating
 
 ## Installation
 
-Requires Python 3.11 or higher.
+Requires Python 3.10 or higher.
 
 ### Using uv (recommended)
 
@@ -63,6 +63,24 @@ The tool searches for configuration in the following locations (in order):
 
 ## Usage
 
+### Global Options
+
+All commands support these global options:
+
+```bash
+router --ip 192.168.1.1 --user admin --pass secret status
+router --json clients
+```
+
+| Option | Environment Variable | Description |
+|--------|---------------------|-------------|
+| `--ip ADDRESS` | `ROUTER_IP` | Router IP address |
+| `--user USERNAME` | `ROUTER_USER` | Username for authentication |
+| `--pass PASSWORD` | `ROUTER_PASS` | Password for authentication |
+| `--json` | - | Output in JSON format (for scripting) |
+
+**Configuration priority**: CLI flags > environment variables > config file > defaults
+
 ### Quick Overview
 
 ```bash
@@ -217,7 +235,7 @@ uv run pytest
 
 ## Compatibility
 
-- **Python**: 3.11+
+- **Python**: 3.10+
 - **Router**: D-Link DSL-2750U (firmware ME_1.00)
 
 This tool may work with other D-Link routers that share a similar web interface, but has only been tested with the DSL-2750U.

{router_cli-0.2.0 → router_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "router-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "CLI tool to manage D-Link DSL-2750U router"
 readme = "README.md"
 authors = [{ name = "d3vr", email = "hi@f3.al" }]

{router_cli-0.2.0 → router_cli-0.3.0}/src/router_cli/__init__.py

@@ -1,3 +1,3 @@
 """Router CLI - Manage D-Link DSL-2750U router."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"

router_cli-0.3.0/src/router_cli/client.py

@@ -0,0 +1,320 @@
+"""HTTP client for D-Link DSL-2750U router."""
+
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from http.cookiejar import CookieJar
+
+from .models import (
+    ADSLStats,
+    AuthenticationError,
+    ConnectionError,
+    DHCPLease,
+    HTTPError,
+    InterfaceStats,
+    LogEntry,
+    Route,
+    RouterError,
+    RouterStatus,
+    Statistics,
+    WANConnection,
+    WirelessClient,
+)
+from .parser import (
+    parse_dhcp_leases,
+    parse_logs,
+    parse_routes,
+    parse_statistics,
+    parse_status,
+    parse_wireless_clients,
+)
+
+# Re-export models for backward compatibility
+__all__ = [
+    "ADSLStats",
+    "AuthenticationError",
+    "ConnectionError",
+    "DHCPLease",
+    "HTTPError",
+    "InterfaceStats",
+    "LogEntry",
+    "Route",
+    "RouterClient",
+    "RouterError",
+    "RouterStatus",
+    "Statistics",
+    "WANConnection",
+    "WirelessClient",
+]
+
+
+class RouterClient:
+    """Client for communicating with D-Link DSL-2750U router."""
+
+    def __init__(self, ip: str, username: str, password: str):
+        self.ip = ip
+        self.username = username
+        self.password = password
+        self.base_url = f"http://{ip}"
+        self.cookie_jar = CookieJar()
+        self.opener = urllib.request.build_opener(
+            urllib.request.HTTPCookieProcessor(self.cookie_jar)
+        )
+        self._authenticated = False
+
+    # Patterns that indicate a login/session expired page
+    _LOGIN_PAGE_PATTERNS = [
+        re.compile(r"<title>\s*Login\s*</title>", re.IGNORECASE),
+        re.compile(r'name=["\']?password["\']?.*type=["\']?password', re.IGNORECASE),
+        re.compile(r"session\s*(has\s*)?expired", re.IGNORECASE),
+        re.compile(r"please\s*log\s*in", re.IGNORECASE),
+        re.compile(r"unauthorized", re.IGNORECASE),
+    ]
+
+    # Patterns that indicate an error page
+    _ERROR_PAGE_PATTERNS = [
+        re.compile(r"<title>\s*Error\s*</title>", re.IGNORECASE),
+        re.compile(r"internal\s*server\s*error", re.IGNORECASE),
+        re.compile(r"service\s*unavailable", re.IGNORECASE),
+        re.compile(r"<h1>\s*\d{3}\s*</h1>", re.IGNORECASE),  # <h1>500</h1> etc.
+    ]
+
+    def _is_login_page(self, html: str) -> bool:
+        """Check if the HTML response is a login/session expired page."""
+        for pattern in self._LOGIN_PAGE_PATTERNS:
+            if pattern.search(html):
+                return True
+        return False
+
+    def _is_error_page(self, html: str) -> tuple[bool, str | None]:
+        """Check if the HTML response is an error page.
+
+        Returns (is_error, error_message).
+        """
+        for pattern in self._ERROR_PAGE_PATTERNS:
+            if pattern.search(html):
+                # Try to extract a meaningful error message
+                title_match = re.search(r"<title>([^<]+)</title>", html, re.IGNORECASE)
+                h1_match = re.search(r"<h1>([^<]+)</h1>", html, re.IGNORECASE)
+                msg = (
+                    title_match.group(1)
+                    if title_match
+                    else (h1_match.group(1) if h1_match else "Unknown error")
+                )
+                return True, msg.strip()
+        return False, None
+
+    def authenticate(self) -> bool:
+        """Authenticate with the router.
+
+        POST to /main with credentials in cookies and form data.
+        """
+        url = f"{self.base_url}/main"
+
+        # URL-encode the password for form data (+ becomes %2B)
+        encoded_password = urllib.parse.quote(self.password, safe="")
+        form_data = f"username={self.username}&password={encoded_password}&loginfo=on"
+
+        # Set auth cookies
+        cookie_header = f"username={self.username}; password={self.password}"
+
+        request = urllib.request.Request(
+            url,
+            data=form_data.encode("utf-8"),
+            headers={
+                "Cookie": cookie_header,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            method="POST",
+        )
+
+        try:
+            with self.opener.open(request, timeout=10) as response:
+                html = response.read().decode("utf-8", errors="replace")
+                # Check if we got redirected to login page (auth failed)
+                if self._is_login_page(html):
+                    self._authenticated = False
+                    raise AuthenticationError(
+                        "Authentication failed: invalid credentials"
+                    )
+                self._authenticated = response.status == 200
+                return self._authenticated
+        except urllib.error.HTTPError as e:
+            raise AuthenticationError(f"Authentication failed: HTTP {e.code}")
+        except urllib.error.URLError as e:
+            raise ConnectionError(
+                f"Failed to connect to router at {self.ip}: {e.reason}"
+            )
+
+    def fetch_page(self, path: str, max_retries: int = 3) -> str:
+        """Fetch a page from the router with authentication cookies.
+
+        Args:
+            path: The page path to fetch (e.g., "/info.html")
+            max_retries: Maximum number of retry attempts for transient failures
+
+        Returns:
+            The HTML content of the page
+
+        Raises:
+            AuthenticationError: If session expired and re-auth fails
+            ConnectionError: If unable to connect to the router
+            HTTPError: If the router returns an HTTP error
+        """
+        if not self._authenticated:
+            self.authenticate()
+
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        cookie_header = f"username={self.username}; password={self.password}"
+
+        last_error: Exception | None = None
+
+        for attempt in range(max_retries):
+            request = urllib.request.Request(
+                url, headers={"Cookie": cookie_header}, method="GET"
+            )
+
+            try:
+                with self.opener.open(request, timeout=10) as response:
+                    html = response.read().decode("utf-8", errors="replace")
+
+                    # Check if we got a login page (session expired)
+                    if self._is_login_page(html):
+                        self._authenticated = False
+                        # Try to re-authenticate once
+                        if attempt == 0:
+                            try:
+                                self.authenticate()
+                                continue  # Retry the request
+                            except AuthenticationError:
+                                raise AuthenticationError(
+                                    "Session expired and re-authentication failed"
+                                )
+                        raise AuthenticationError("Session expired")
+
+                    # Check if we got an error page
+                    is_error, error_msg = self._is_error_page(html)
+                    if is_error:
+                        # Some error pages are transient, retry
+                        if attempt < max_retries - 1:
+                            time.sleep(1 * (attempt + 1))  # Backoff
+                            continue
+                        raise HTTPError(f"Router returned error page: {error_msg}")
+
+                    return html
+
+            except urllib.error.HTTPError as e:
+                last_error = e
+                # Read the error body for better diagnostics
+                try:
+                    error_body = e.read().decode("utf-8", errors="replace")[:200]
+                except Exception:
+                    error_body = ""
+
+                # Retry on 5xx errors (server-side issues)
+                if 500 <= e.code < 600 and attempt < max_retries - 1:
+                    time.sleep(1 * (attempt + 1))  # Exponential backoff
+                    continue
+
+                # Provide helpful error message based on status code
+                if e.code == 401:
+                    self._authenticated = False
+                    raise AuthenticationError("Authentication required (401)")
+                elif e.code == 403:
+                    raise AuthenticationError("Access forbidden (403)")
+                elif e.code == 404:
+                    raise HTTPError(f"Page not found: {path}", status_code=404)
+                elif e.code == 503:
+                    raise HTTPError(
+                        "Router is busy or unavailable (503). Try again later.",
+                        status_code=503,
+                    )
+                else:
+                    # Include snippet of error body for debugging
+                    snippet = error_body[:100].replace("\n", " ").strip()
+                    raise HTTPError(
+                        f"HTTP {e.code} fetching {path}: {snippet or e.reason}",
+                        status_code=e.code,
+                    )
+
+            except urllib.error.URLError as e:
+                last_error = e
+                # Retry on network errors
+                if attempt < max_retries - 1:
+                    time.sleep(1 * (attempt + 1))
+                    continue
+                raise ConnectionError(f"Failed to connect to {self.ip}: {e.reason}")
+
+            except TimeoutError:
+                last_error = TimeoutError(f"Request to {path} timed out")
+                if attempt < max_retries - 1:
+                    time.sleep(1 * (attempt + 1))
+                    continue
+                raise ConnectionError(
+                    f"Request to {path} timed out after {max_retries} attempts"
+                )
+
+        # Should not reach here, but just in case
+        raise ConnectionError(
+            f"Failed to fetch {path} after {max_retries} attempts: {last_error}"
+        )
+
+    def get_session_key(self, html: str) -> str:
+        """Extract session key from HTML page."""
+        match = re.search(r"var\s+sessionKey\s*=\s*[\"']([^\"']+)[\"']", html)
+        if match:
+            return match.group(1)
+        raise ValueError("Could not find session key in page")
+
+    def get_status(self) -> RouterStatus:
+        """Fetch and parse router status."""
+        html = self.fetch_page("/info.html")
+        return parse_status(html)
+
+    def reboot(self) -> bool:
+        """Reboot the router."""
+        # First get session key from internet.html
+        html = self.fetch_page("/internet.html")
+        session_key = self.get_session_key(html)
+
+        # POST to rebootinfo.cgi
+        url = f"{self.base_url}/rebootinfo.cgi?sessionKey={session_key}"
+        cookie_header = f"username={self.username}; password={self.password}"
+
+        request = urllib.request.Request(
+            url, headers={"Cookie": cookie_header}, method="POST", data=b""
+        )
+
+        try:
+            with self.opener.open(request, timeout=10) as response:
+                return response.status == 200
+        except urllib.error.URLError:
+            # Router may disconnect during reboot, this is expected
+            return True
+
+    def get_wireless_clients(self) -> list[WirelessClient]:
+        """Fetch and parse wireless clients."""
+        html = self.fetch_page("/wlstationlist.cmd")
+        return parse_wireless_clients(html)
+
+    def get_dhcp_leases(self) -> list[DHCPLease]:
+        """Fetch and parse DHCP leases."""
+        html = self.fetch_page("/dhcpinfo.html")
+        return parse_dhcp_leases(html)
+
+    def get_routes(self) -> list[Route]:
+        """Fetch and parse routing table."""
+        html = self.fetch_page("/rtroutecfg.cmd?action=dlinkau")
+        return parse_routes(html)
+
+    def get_statistics(self) -> Statistics:
+        """Fetch and parse network statistics."""
+        html = self.fetch_page("/statsifcwanber.html")
+        return parse_statistics(html)
+
+    def get_logs(self) -> list[LogEntry]:
+        """Fetch and parse system logs."""
+        html = self.fetch_page("/logview.cmd")
+        return parse_logs(html)

router_cli-0.3.0/src/router_cli/commands.py

@@ -0,0 +1,227 @@
+"""Command handlers for the router CLI."""
+
+import json
+import sys
+from dataclasses import asdict
+
+from .client import (
+    AuthenticationError,
+    ConnectionError,
+    HTTPError,
+    RouterClient,
+    RouterError,
+)
+from .config import KnownDevices
+from .display import spinner
+from .formatters import (
+    format_clients,
+    format_dhcp,
+    format_logs,
+    format_overview,
+    format_routes,
+    format_stats,
+    format_status,
+)
+
+
+def _handle_error(e: Exception, json_output: bool = False) -> int:
+    """Handle exceptions and print user-friendly error messages.
+
+    Returns the exit code to use.
+    """
+    error_info = {"error": str(e), "type": type(e).__name__}
+
+    if isinstance(e, AuthenticationError):
+        error_info["hint"] = "Check your username/password in the config file."
+        error_info["code"] = 2
+    elif isinstance(e, ConnectionError):
+        error_info["hint"] = "Ensure the router is reachable and the IP is correct."
+        error_info["code"] = 3
+    elif isinstance(e, HTTPError):
+        error_info["code"] = 4
+        if e.status_code == 503:
+            error_info["hint"] = "The router may be busy. Wait a moment and try again."
+        error_info["status_code"] = e.status_code
+    elif isinstance(e, RouterError):
+        error_info["code"] = 1
+    else:
+        error_info["code"] = 1
+
+    if json_output:
+        print(json.dumps(error_info, indent=2), file=sys.stderr)
+    else:
+        if isinstance(e, AuthenticationError):
+            print(f"Authentication error: {e}", file=sys.stderr)
+            print(
+                "  Hint: Check your username/password in the config file.",
+                file=sys.stderr,
+            )
+        elif isinstance(e, ConnectionError):
+            print(f"Connection error: {e}", file=sys.stderr)
+            print(
+                "  Hint: Ensure the router is reachable and the IP is correct.",
+                file=sys.stderr,
+            )
+        elif isinstance(e, HTTPError):
+            print(f"Router error: {e}", file=sys.stderr)
+            if e.status_code == 503:
+                print(
+                    "  Hint: The router may be busy. Wait a moment and try again.",
+                    file=sys.stderr,
+                )
+        elif isinstance(e, RouterError):
+            print(f"Router error: {e}", file=sys.stderr)
+        else:
+            print(f"Unexpected error ({type(e).__name__}): {e}", file=sys.stderr)
+
+    return error_info["code"]
+
+
+def _to_json(obj) -> str:
+    """Convert dataclass or list of dataclasses to JSON."""
+    if isinstance(obj, list):
+        return json.dumps([asdict(item) for item in obj], indent=2)
+    return json.dumps(asdict(obj), indent=2)
+
+
+def cmd_status(client: RouterClient, json_output: bool = False) -> int:
+    """Execute status command."""
+    try:
+        with spinner("Fetching router status..."):
+            status = client.get_status()
+        if json_output:
+            # Convert WANConnection objects to dicts for JSON
+            data = asdict(status)
+            print(json.dumps(data, indent=2))
+        else:
+            print(format_status(status))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)
+
+
+def cmd_reboot(client: RouterClient) -> int:
+    """Execute reboot command."""
+    try:
+        with spinner("Sending reboot command..."):
+            client.reboot()
+        print("Reboot command sent successfully.")
+        print("The router will restart in a few seconds.")
+        return 0
+    except Exception as e:
+        return _handle_error(e)
+
+
+def cmd_clients(
+    client: RouterClient, known_devices: KnownDevices, json_output: bool = False
+) -> int:
+    """Execute clients command."""
+    try:
+        with spinner("Fetching wireless clients..."):
+            clients = client.get_wireless_clients()
+        if json_output:
+            print(_to_json(clients))
+        else:
+            print(format_clients(clients, known_devices))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)
+
+
+def cmd_dhcp(
+    client: RouterClient, known_devices: KnownDevices, json_output: bool = False
+) -> int:
+    """Execute dhcp command."""
+    try:
+        with spinner("Fetching DHCP leases..."):
+            leases = client.get_dhcp_leases()
+        if json_output:
+            print(_to_json(leases))
+        else:
+            print(format_dhcp(leases, known_devices))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)
+
+
+def cmd_routes(client: RouterClient, json_output: bool = False) -> int:
+    """Execute routes command."""
+    try:
+        with spinner("Fetching routing table..."):
+            routes = client.get_routes()
+        if json_output:
+            print(_to_json(routes))
+        else:
+            print(format_routes(routes))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)
+
+
+def cmd_stats(client: RouterClient, json_output: bool = False) -> int:
+    """Execute stats command."""
+    try:
+        with spinner("Fetching network statistics..."):
+            stats = client.get_statistics()
+        if json_output:
+            print(_to_json(stats))
+        else:
+            print(format_stats(stats))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)
+
+
+def cmd_logs(
+    client: RouterClient,
+    tail: int | None = None,
+    level: str | None = None,
+    json_output: bool = False,
+) -> int:
+    """Execute logs command."""
+    try:
+        with spinner("Fetching system logs..."):
+            logs = client.get_logs()
+
+        # Filter by severity level if specified
+        if level:
+            level_upper = level.upper()
+            logs = [log for log in logs if log.severity.upper() == level_upper]
+
+        # Limit to last N entries if tail specified
+        if tail and tail > 0:
+            logs = logs[-tail:]
+
+        if json_output:
+            print(_to_json(logs))
+        else:
+            print(format_logs(logs))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)
+
+
+def cmd_overview(
+    client: RouterClient, known_devices: KnownDevices, json_output: bool = False
+) -> int:
+    """Execute overview command."""
+    try:
+        with spinner("Fetching router overview..."):
+            status = client.get_status()
+            clients = client.get_wireless_clients()
+            leases = client.get_dhcp_leases()
+            stats = client.get_statistics()
+
+        if json_output:
+            data = {
+                "status": asdict(status),
+                "wireless_clients": [asdict(c) for c in clients],
+                "dhcp_leases": [asdict(lease) for lease in leases],
+                "statistics": asdict(stats),
+            }
+            print(json.dumps(data, indent=2))
+        else:
+            print(format_overview(status, clients, leases, stats, known_devices))
+        return 0
+    except Exception as e:
+        return _handle_error(e, json_output)