monitorify 1.0.2__tar.gz → 1.1.0__tar.gz

monitorify-1.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: monitorify
+Version: 1.1.0
+Summary: A lightweight Linux terminal system monitor built with Textual
+Author: Leon
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=0.80.0
+Requires-Dist: platformdirs>=4.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: keyring>=24.0.0
+
+# Monitorify
+### A terminal montioring tool for linux
+
+- Features
+- CPU monitoring 
+- RAM monitoring
+- Network monitoring
+- Disk monitoring (I/O and storage capacity)
+- Process monitoring
+- Background daemon
+- Customization menu (toggle widgets, set intervals, and change history window)
+- Historical graphs
+
+## Requirements
+
+* **Python:** 3.10+
+* **OS:** Linux (relies on `/proc` and `/sys` filesystems)
+* **Terminal:** Minimum 80 columns × 24 lines recommended
+
+## Installation
+### Using pipx
+```bash
+pipx install git+https://github.com/leonst036/Monitorify.git
+```
+Or from PyPI:
+```bash
+pipx install monitorify
+```
+
+### Using pip
+```bash
+pip install git+https://github.com/leonst036/Monitorify.git
+```
+
+### Using source
+```bash
+git clone https://github.com/leonst036/Monitorify.git
+cd Monitorify
+pip install . 
+```
+
+## Usage
+```bash
+monitorify
+```
+
+## Background Daemon
+
+The daemon collects metrics continuously to SQLite, even when the dashboard is closed.
+
+### Manually (foreground)
+
+```bash
+monitorify-daemon
+```
+
+### Always-On via systemd --user
+
+Create the service file at `~/.config/systemd/user/monitorify.service`:
+
+```ini
+[Unit]
+Description=Monitorify Metrics Collector Daemon
+
+[Service]
+ExecStart=%h/.local/bin/monitorify-daemon
+Restart=always
+
+[Install]
+WantedBy=default.target
+```
+
+Enable and start it:
+
+```bash
+systemctl --user daemon-reload
+systemctl --user enable --now monitorify
+```
+
+Check status or logs:
+
+```bash
+systemctl --user status monitorify
+journalctl --user -u monitorify -f
+```
+
+Stop or disable:
+
+```bash
+systemctl --user stop monitorify
+systemctl --user disable monitorify
+```
+
+## File Locations
+
+Monitorify follows XDG Base Directory conventions — nothing is written to the install directory.
+
+| Purpose | Default Path | Override |
+|---|---|---|
+| **Database** | `~/.local/share/monitorify/monitorify.db` | `MONITORIFY_DB_PATH` env var |
+| **Daemon PID** | `/run/user/<uid>/monitorify/daemon.pid` | `MONITORIFY_PID_PATH` env var |
+| **Collection interval** | `1.0` seconds | `MONITORIFY_INTERVAL` env var |
+| **Data retention** | `604800` s (7 days) | `MONITORIFY_RETENTION` env var |
+
+## Remote
+
+To use Monitorify remotely over SSH on your server, you can set the following parameters:
+
+- `--ip` – Set the target IP address.
+- `--port` – Set the SSH port.
+- `--username` – Set the username for the remote host.
+- `--password` – Set the password for the SSH server.
+- `--key_filename` – Set the path to an SSH key *(optional)*.
+- `--host` – Manage remote hosts in the database (`add`, `list`, `remove`).
+
+## Tech Stack
+
+* **Language & TUI:** Python, Textual
+* **Database:** SQLite
+* **Target OS:** Linux
+
+## Uninstalling
+
+```bash
+# If installed via pipx
+pipx uninstall monitorify
+
+# Remove stored data
+rm -rf ~/.local/share/monitorify
+rm -rf /run/user/$(id -u)/monitorify
+```

monitorify-1.1.0/README.md

@@ -0,0 +1,131 @@
+# Monitorify
+### A terminal montioring tool for linux
+
+- Features
+- CPU monitoring 
+- RAM monitoring
+- Network monitoring
+- Disk monitoring (I/O and storage capacity)
+- Process monitoring
+- Background daemon
+- Customization menu (toggle widgets, set intervals, and change history window)
+- Historical graphs
+
+## Requirements
+
+* **Python:** 3.10+
+* **OS:** Linux (relies on `/proc` and `/sys` filesystems)
+* **Terminal:** Minimum 80 columns × 24 lines recommended
+
+## Installation
+### Using pipx
+```bash
+pipx install git+https://github.com/leonst036/Monitorify.git
+```
+Or from PyPI:
+```bash
+pipx install monitorify
+```
+
+### Using pip
+```bash
+pip install git+https://github.com/leonst036/Monitorify.git
+```
+
+### Using source
+```bash
+git clone https://github.com/leonst036/Monitorify.git
+cd Monitorify
+pip install . 
+```
+
+## Usage
+```bash
+monitorify
+```
+
+## Background Daemon
+
+The daemon collects metrics continuously to SQLite, even when the dashboard is closed.
+
+### Manually (foreground)
+
+```bash
+monitorify-daemon
+```
+
+### Always-On via systemd --user
+
+Create the service file at `~/.config/systemd/user/monitorify.service`:
+
+```ini
+[Unit]
+Description=Monitorify Metrics Collector Daemon
+
+[Service]
+ExecStart=%h/.local/bin/monitorify-daemon
+Restart=always
+
+[Install]
+WantedBy=default.target
+```
+
+Enable and start it:
+
+```bash
+systemctl --user daemon-reload
+systemctl --user enable --now monitorify
+```
+
+Check status or logs:
+
+```bash
+systemctl --user status monitorify
+journalctl --user -u monitorify -f
+```
+
+Stop or disable:
+
+```bash
+systemctl --user stop monitorify
+systemctl --user disable monitorify
+```
+
+## File Locations
+
+Monitorify follows XDG Base Directory conventions — nothing is written to the install directory.
+
+| Purpose | Default Path | Override |
+|---|---|---|
+| **Database** | `~/.local/share/monitorify/monitorify.db` | `MONITORIFY_DB_PATH` env var |
+| **Daemon PID** | `/run/user/<uid>/monitorify/daemon.pid` | `MONITORIFY_PID_PATH` env var |
+| **Collection interval** | `1.0` seconds | `MONITORIFY_INTERVAL` env var |
+| **Data retention** | `604800` s (7 days) | `MONITORIFY_RETENTION` env var |
+
+## Remote
+
+To use Monitorify remotely over SSH on your server, you can set the following parameters:
+
+- `--ip` – Set the target IP address.
+- `--port` – Set the SSH port.
+- `--username` – Set the username for the remote host.
+- `--password` – Set the password for the SSH server.
+- `--key_filename` – Set the path to an SSH key *(optional)*.
+- `--host` – Manage remote hosts in the database (`add`, `list`, `remove`).
+
+## Tech Stack
+
+* **Language & TUI:** Python, Textual
+* **Database:** SQLite
+* **Target OS:** Linux
+
+## Uninstalling
+
+```bash
+# If installed via pipx
+pipx uninstall monitorify
+
+# Remove stored data
+rm -rf ~/.local/share/monitorify
+rm -rf /run/user/$(id -u)/monitorify
+```

{monitorify-1.0.2 → monitorify-1.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "monitorify"
-version = "1.0.2"
+version = "1.1.0"
 description = "A lightweight Linux terminal system monitor built with Textual"
 readme = "README.md"
 authors = [
@@ -16,6 +16,8 @@ dependencies = [
     "textual>=0.80.0",
     "platformdirs>=4.0.0",
     "rich>=13.0.0",
+    "paramiko>=3.0.0",
+    "keyring>=24.0.0",
 ]
 
 [project.scripts]
@@ -27,3 +29,4 @@ where = ["src"]
 
 [tool.setuptools.package-data]
 "monitorify.ui.tui" = ["css/*.css"]
+"monitorify.remote" = ["*.sh"]

{monitorify-1.0.2 → monitorify-1.1.0}/src/monitorify/__init__.py

@@ -1,3 +1,3 @@
 """Monitorify - A lightweight Linux terminal system monitor."""
 
-__version__ = "1.0.2"
+__version__ = "1.1.0"

{monitorify-1.0.2 → monitorify-1.1.0}/src/monitorify/config.py

@@ -22,7 +22,7 @@ CONFIG_PATH = Path(os.getenv("MONITORIFY_CONFIG_PATH", str(DATA_DIR / "config.js
 # Daemon PID file path
 DAEMON_PIDFILE = Path(os.getenv("MONITORIFY_PID_PATH", str(RUNTIME_DIR / "daemon.pid")))
 
-# Collection settings (seconds)
+# Collection settings
 DEFAULT_COLLECTION_INTERVAL = float(os.getenv("MONITORIFY_INTERVAL", "1.0"))
 
 # Retention settings (default: 7 days in seconds)

{monitorify-1.0.2 → monitorify-1.1.0}/src/monitorify/main.py

@@ -13,9 +13,17 @@ def parse_args():
     parser.add_argument("--username", type=str, default=None, help="Username for the remote machine")
     parser.add_argument("--password", type=str, default=None, help="Password for the remote machine")
     parser.add_argument("--key_filename", type=str, default=None, help="Path to the key file for the remote machine")
+    parser.add_argument("--command", type=str, default=None, help="Command to run on the remote machine")
+    parser.add_argument(
+        "--host",
+        type=str,
+        choices=["add", "list", "remove", "delete"],
+        default=None,
+        help="Manage remote hosts (e.g. add, list, remove)",
+    )
     args = parser.parse_args()
 
-    if not args.ip and (args.port is not None or args.username or args.password or args.key_filename):
+    if not args.ip and not args.host and (args.port is not None or args.username or args.password or args.key_filename):
         parser.error("--ip is required when specifying remote connection arguments")
 
     return args
@@ -50,42 +58,28 @@ def start_daemon() -> subprocess.Popen | None:
 
 
 def cli():
-    """Main CLI entrypoint"""
+    """Main CLI entrypoint."""
     args = parse_args()
 
-    if args.ip:
-        from monitorify.remote.connector import RemoteConnector
-
-        try:
-            connector = RemoteConnector(
-                host=args.ip,
-                port=args.port or 22,
-                username=args.username,
-                password=args.password,
-                key_filename=args.key_filename,
-            )
-            client = connector.connect()
-            try:
-                if not args.command and not connector.is_installed(client):
-                    print(f"Error: Monitorify is not installed on the remote host ({args.ip}).")
-                    response = input("Do you want to install it? (y/n): ").strip().lower()
-                    if response == "y":
-                        success = connector.install(client)
-                        if not success:
-                            print("Installation failed.")
-                            sys.exit(1)
-                    else:
-                        sys.exit(1)
-
-                remote_cmd = args.command or "bash -l -c 'monitorify || python3 -m monitorify'"
-                connector.run_interactive(client, command=remote_cmd)
-            finally:
-                client.close()
-        except ConnectionError as e:
-            print(f"Connection failed: {e}")
+    if args.host:
+        from monitorify.remote.addRemote import handle_host_action
+
+        handle_host_action(args.host, args)
+        return
+    elif args.ip:
+        from monitorify.remote.connector import connect_and_run
+
+        success = connect_and_run(
+            host=args.ip,
+            port=args.port or 22,
+            username=args.username,
+            password=args.password,
+            key_filename=args.key_filename,
+            command=args.command,
+            pause_on_exit=False,
+        )
+        if not success:
             sys.exit(1)
-        except KeyboardInterrupt:
-            pass
         return
 
     # Local mode

monitorify-1.1.0/src/monitorify/remote/__init__.py

@@ -0,0 +1,4 @@
+from monitorify.remote.connector import RemoteConnector
+from monitorify.remote.addRemote import add_remote, list_hosts, remove_host, handle_host_action
+
+__all__ = ["RemoteConnector", "add_remote", "list_hosts", "remove_host", "handle_host_action"]

monitorify-1.1.0/src/monitorify/remote/addRemote.py

@@ -0,0 +1,157 @@
+import getpass
+import os
+from typing import Optional
+from monitorify.storage.db import Database
+
+
+def add_remote(
+    ip: Optional[str] = None,
+    port: Optional[int] = None,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    key_filename: Optional[str] = None,
+    db: Optional[Database] = None,
+) -> int:
+    """Prompt for remote host details if not provided, and save to database."""
+    if not ip:
+        ip = input("Enter IP address: ").strip()
+    if not ip:
+        print("Error: IP address cannot be empty.")
+        return -1
+
+    if port is None:
+        port_input = input("Enter port (default 22): ").strip()
+        port = int(port_input) if port_input.isdigit() else 22
+    elif isinstance(port, str):
+        port = int(port) if port.isdigit() else 22
+
+    if not (1 <= port <= 65535):
+        port = 22
+
+    if username is None:
+        username_input = input("Enter username (default root): ").strip()
+        username = username_input if username_input else "root"
+    else:
+        username = username.strip() or "root"
+
+    if password is None and key_filename is None:
+        password_input = getpass.getpass("Enter password (leave blank to use SSH keys): ").strip()
+        if password_input:
+            password = password_input
+            key_filename = None
+        else:
+            password = None
+            key_input = input("Enter key filename: ").strip()
+            key_filename = key_input if key_input else None
+    else:
+        password = password if password else None
+        key_filename = key_filename if key_filename else None
+
+    if key_filename:
+        key_filename = os.path.expanduser(key_filename)
+
+    close_db = False
+    if db is None:
+        db = Database()
+        close_db = True
+
+    try:
+        host_id = db.save_host(
+            ip=ip,
+            port=port,
+            username=username,
+            password=password,
+            key_filename=key_filename,
+        )
+        if host_id != -1:
+            print(f"Host '{username}@{ip}:{port}' saved to database (ID: {host_id}).")
+        else:
+            print("Failed to save host to database.")
+        return host_id
+    finally:
+        if close_db:
+            db.disconnect()
+
+
+def list_hosts(db: Optional[Database] = None) -> list[dict]:
+    """List all saved remote hosts."""
+    close_db = False
+    if db is None:
+        db = Database()
+        close_db = True
+
+    try:
+        hosts = db.get_hosts()
+        if not hosts:
+            print("No saved hosts found.")
+            return []
+
+        print(f"{'ID':<5} {'Host':<35} {'Auth':<20}")
+        print("-" * 65)
+        for h in hosts:
+            host_str = f"{h['username']}@{h['ip']}:{h['port']}"
+            auth_str = f"Key: {h['key_filename']}" if h['key_filename'] else ("Password: ***" if h['password'] else "None")
+            print(f"{h['id']:<5} {host_str:<35} {auth_str:<20}")
+        return hosts
+    finally:
+        if close_db:
+            db.disconnect()
+
+
+def remove_host(host_id: Optional[int] = None, db: Optional[Database] = None) -> bool:
+    """Remove a saved remote host by ID."""
+    close_db = False
+    if db is None:
+        db = Database()
+        close_db = True
+
+    try:
+        if host_id is None:
+            hosts = db.get_hosts()
+            if not hosts:
+                print("No saved hosts to remove.")
+                return False
+            list_hosts(db=db)
+            id_input = input("Enter host ID to remove: ").strip()
+            if not id_input.isdigit():
+                print("Invalid host ID.")
+                return False
+            host_id = int(id_input)
+
+        if db.delete_host(host_id):
+            print(f"Host ID {host_id} successfully deleted.")
+            return True
+        else:
+            print(f"Failed to delete host ID {host_id}.")
+            return False
+    finally:
+        if close_db:
+            db.disconnect()
+
+
+def handle_host_action(action: str, args=None) -> None:
+    """Handle --host subcommands."""
+    action = (action or "").lower()
+    if action == "add":
+        ip = getattr(args, "ip", None)
+        port = getattr(args, "port", None)
+        username = getattr(args, "username", None)
+        password = getattr(args, "password", None)
+        key_filename = getattr(args, "key_filename", None)
+        add_remote(
+            ip=ip,
+            port=port,
+            username=username,
+            password=password,
+            key_filename=key_filename,
+        )
+    elif action == "list":
+        list_hosts()
+    elif action in ("remove", "delete"):
+        remove_host()
+    else:
+        print(f"Unknown host action: '{action}'. Supported actions: add, list, remove")
+
+
+if __name__ == "__main__":
+    add_remote()

{monitorify-1.0.2 → monitorify-1.1.0}/src/monitorify/remote/connector.py

@@ -1,5 +1,7 @@
+import os
 import paramiko
 
+
 class RemoteConnector:
     def __init__(
         self,
@@ -8,18 +10,27 @@ class RemoteConnector:
         username: str | None = None,
         password: str | None = None,
         key_filename: str | None = None,
+        timeout: float = 10.0,
     ):
         self.host = host
         self.port = port
         self.username = username
         self.password = password
-        self.key_filename = key_filename
+        self.key_filename = os.path.expanduser(key_filename) if key_filename else None
+        self.timeout = timeout
 
-    def connect(self):
+    def connect(self) -> paramiko.SSHClient:
         client = paramiko.SSHClient()
         client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-        try: 
-            client.connect(hostname=self.host, port=self.port, username=self.username, password=self.password, key_filename=self.key_filename)
+        try:
+            client.connect(
+                hostname=self.host,
+                port=self.port,
+                username=self.username,
+                password=self.password,
+                key_filename=self.key_filename,
+                timeout=self.timeout,
+            )
         except paramiko.AuthenticationException as e:
             raise ConnectionError(f"Authentication failed: {e}")
         except paramiko.SSHException as e:
@@ -32,7 +43,7 @@ class RemoteConnector:
         """Check if monitorify is installed on the remote host."""
         try:
             _, stdout, _ = client.exec_command(
-                "bash -l -c 'command -v monitorify >/dev/null 2>&1 || python3 -c \"import monitorify\" >/dev/null 2>&1'"
+                "bash -l -c 'export PATH=\"$HOME/.local/bin:$PATH\"; command -v monitorify >/dev/null 2>&1 || [ -x \"$HOME/.local/bin/monitorify\" ] || python3 -c \"import monitorify\" >/dev/null 2>&1'"
             )
             return stdout.channel.recv_exit_status() == 0
         except Exception:
@@ -51,7 +62,6 @@ class RemoteConnector:
 
     def run_interactive(self, client: paramiko.SSHClient, command: str = "monitorify") -> None:
         """Run a command interactively on the remote host with a PTY."""
-        import os
         import select
         import shutil
         import signal
@@ -81,8 +91,9 @@ class RemoteConnector:
             except Exception:
                 pass
 
+        old_winch_handler = None
         try:
-            signal.signal(signal.SIGWINCH, handle_resize)
+            old_winch_handler = signal.signal(signal.SIGWINCH, handle_resize)
         except Exception:
             pass
 
@@ -110,6 +121,69 @@ class RemoteConnector:
                     except Exception:
                         break
         finally:
+            if old_winch_handler is not None:
+                try:
+                    signal.signal(signal.SIGWINCH, old_winch_handler)
+                except Exception:
+                    pass
             if is_atty and old_tty is not None:
                 termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_tty)
-            channel.close()
+            channel.close()
+
+
+def connect_and_run(
+    host: str,
+    port: int = 22,
+    username: str | None = None,
+    password: str | None = None,
+    key_filename: str | None = None,
+    command: str | None = None,
+    pause_on_exit: bool = False,
+    timeout: float = 10.0,
+) -> bool:
+    """Connects to a remote host and runs the interactive session."""
+    connector = RemoteConnector(
+        host=host,
+        port=port or 22,
+        username=username,
+        password=password,
+        key_filename=key_filename,
+        timeout=timeout,
+    )
+    try:
+        print(f"\nConnecting to {username or 'root'}@{host}:{port or 22}...")
+        client = connector.connect()
+        try:
+            if not command and not connector.is_installed(client):
+                print(f"Error: Monitorify is not installed on the remote host ({host}).")
+                response = input("Do you want to install it? (y/n): ").strip().lower()
+                if response == "y":
+                    success = connector.install(client)
+                    if not success:
+                        print("Installation failed.")
+                        if pause_on_exit:
+                            input("Press Enter to return...")
+                        return False
+                else:
+                    if pause_on_exit:
+                        input("Press Enter to return...")
+                    return False
+
+            remote_cmd = command or "bash -l -c 'export PATH=\"$HOME/.local/bin:$PATH\"; monitorify || python3 -m monitorify'"
+            connector.run_interactive(client, command=remote_cmd)
+            return True
+        finally:
+            client.close()
+    except ConnectionError as e:
+        print(f"Connection failed: {e}")
+        if pause_on_exit:
+            input("Press Enter to return...")
+        return False
+    except KeyboardInterrupt:
+        print("\nSession cancelled.")
+        return False
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        if pause_on_exit:
+            input("Press Enter to return...")
+        return False