tunnelmate-cli 1.0.2__tar.gz → 1.0.4__tar.gz

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunnelmate-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Cloudflare Quick Tunnel manager with CLI, Interactive TUI, Daemon IPC, and Telegram Bot
 Author-email: Shashan Lumbhani <lumbhanishashan1510@gmail.com>
 License: MIT

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tunnelmate-cli"
-version = "1.0.2"
+version = "1.0.4"
 description = "Cloudflare Quick Tunnel manager with CLI, Interactive TUI, Daemon IPC, and Telegram Bot"
 readme = "README.md"
 requires-python = ">=3.10"

tunnelmate_cli-1.0.4/tests/test_cross_platform.py

@@ -0,0 +1,84 @@
+"""Tests for cross-platform process management and Windows/Linux compatibility."""
+
+import os
+import sys
+from pathlib import Path
+from tunnelmate.core.process import is_pid_alive, spawn_background_process, terminate_process_by_pid
+from tunnelmate.core.cloudflared import find_cloudflared
+from tunnelmate.cli.ssh_client import clean_ssh_target
+
+
+def test_is_pid_alive():
+    # Current process must be alive
+    assert is_pid_alive(os.getpid()) is True
+    # Non-existent PID must not be alive
+    assert is_pid_alive(99999999) is False
+    assert is_pid_alive(-1) is False
+
+
+def test_spawn_and_terminate_process():
+    # Launch a short-lived python background sleep process
+    cmd = [sys.executable, "-c", "import time; time.sleep(10)"]
+    proc = spawn_background_process(cmd)
+    pid = proc.pid
+    assert pid is not None
+    assert is_pid_alive(pid) is True
+
+    # Terminate process safely using cross-platform helper
+    terminated = terminate_process_by_pid(pid, timeout=3.0)
+    assert terminated is True
+    assert is_pid_alive(pid) is False
+
+
+def test_clean_ssh_target_windows_formats():
+    assert clean_ssh_target("shashan@subjective.trycloudflare.com") == "shashan@subjective.trycloudflare.com"
+    assert clean_ssh_target("shashan@https://subjective.trycloudflare.com/") == "shashan@subjective.trycloudflare.com"
+    assert clean_ssh_target("https://subjective.trycloudflare.com:22") == "subjective.trycloudflare.com"
+
+
+def test_bot_auto_start_persistence(tmp_path: Path):
+    from tunnelmate.config import Settings, load_settings, save_settings
+
+    st = Settings(home_dir=tmp_path, bot_auto_start=False)
+    assert st.bot_auto_start is False
+
+    st.bot_auto_start = True
+    save_settings(st)
+
+    loaded = load_settings(custom_home=tmp_path)
+    assert loaded.bot_auto_start is True
+
+
+def test_autostart_status_query():
+    from tunnelmate.core.autostart import is_autostart_enabled
+
+    # Should return a tuple of (bool, str) without throwing exceptions
+    enabled, details = is_autostart_enabled()
+    assert isinstance(enabled, bool)
+    assert isinstance(details, str)
+
+
+def test_daemon_startup_auto_restoration(tmp_path: Path):
+    from tunnelmate.config import Settings
+    from tunnelmate.db.repository import Repository
+    from tunnelmate.core.models import Tunnel, TunnelStatus, TunnelProtocol
+
+    st = Settings(home_dir=tmp_path, bot_auto_start=True, telegram_bot_token="test_token")
+    repo = Repository(st.resolved_db_path)
+
+    # Create one running tunnel and one stopped tunnel
+    t1 = Tunnel(id="t1", name="running-web", target_port=8080, protocol=TunnelProtocol.HTTP, status=TunnelStatus.RUNNING)
+    t2 = Tunnel(id="t2", name="stopped-ssh", target_port=22, protocol=TunnelProtocol.TCP, status=TunnelStatus.STOPPED)
+    repo.create_tunnel(t1)
+    repo.create_tunnel(t2)
+
+    # Check repository tunnels
+    tunnels = repo.list_tunnels()
+    to_restore = [t for t in tunnels if t.status.value in ("running", "starting", "restarting")]
+    assert len(to_restore) == 1
+    assert to_restore[0].name == "running-web"
+
+    # Verify bot_auto_start setting is preserved
+    assert st.bot_auto_start is True
+
+

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/__init__.py

@@ -5,5 +5,5 @@ Provides CLI, interactive TUI, background daemon, Unix socket IPC, SQLite persis
 and Telegram Bot management.
 """
 
-__version__ = "1.0.2"
+__version__ = "1.0.4"
 __all__ = ["__version__"]

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/bot/telegram_bot.py

@@ -26,7 +26,7 @@ from telegram.ext import (
 )
 
 from tunnelmate.client.ipc_client import TunnelMateClient
-from tunnelmate.config import Settings, load_settings
+from tunnelmate.config import Settings, load_settings, save_settings
 from tunnelmate.core.models import HealthStatus, Tunnel, TunnelProtocol, TunnelStatus
 from tunnelmate.core.process import is_pid_alive
 from tunnelmate.daemon.protocol import IPCRequest, IPCResponse
@@ -704,6 +704,16 @@ class TunnelMateBot:
 
         self._write_pid()
 
+        # Mark bot last status as started so after system reboot it automatically starts
+        try:
+            curr = load_settings()
+            if not curr.bot_auto_start:
+                curr.bot_auto_start = True
+                save_settings(curr)
+            self.settings = curr
+        except Exception as e:
+            logger.debug("Failed to persist bot_auto_start state: %s", e)
+
         request_config = HTTPXRequest(
             connection_pool_size=8,
             read_timeout=30.0,

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/cli/formatting.py

@@ -172,6 +172,7 @@ def print_bot_status_panel(
     has_token: bool,
     has_pwd: bool,
     admin_chat_ids: List[int],
+    bot_auto_start: bool = False,
 ) -> None:
     """Display Telegram bot operational status panel."""
     status_text = f"🟢 RUNNING (PID: {pid})" if is_running else "🔴 STOPPED"
@@ -189,6 +190,10 @@ def print_bot_status_panel(
     if admin_chat_ids:
         admin_info += f" ({', '.join(str(cid) for cid in admin_chat_ids)})"
     table.add_row("Admin Whitelist:", admin_info)
+    table.add_row(
+        "Auto-Restore on Boot:",
+        "✅ Enabled (Starts automatically after restart)" if bot_auto_start else "❌ Disabled",
+    )
 
     console.print(Panel(table, title="🤖 Telegram Bot Controller", border_style="cyan"))
 

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/cli/interactive.py

@@ -87,6 +87,7 @@ def run_interactive_menu(client: Optional[TunnelMateClient] = None) -> None:
                 "🗑️ Delete a Tunnel",
                 "📊 Daemon Statistics",
                 "🤖 Telegram Bot Management",
+                "⚙️ Auto-Start on Boot Settings",
                 "🚪 Exit",
             ],
         ).ask()
@@ -99,6 +100,10 @@ def run_interactive_menu(client: Optional[TunnelMateClient] = None) -> None:
             _handle_telegram_bot_menu()
             continue
 
+        if choice == "⚙️ Auto-Start on Boot Settings":
+            _handle_autostart_menu()
+            continue
+
         try:
             if choice == "📋 List All Tunnels & URLs":
                 tunnels = client.list_tunnels()
@@ -248,6 +253,7 @@ def _handle_telegram_bot_menu() -> None:
             has_token=has_token,
             has_pwd=has_pwd,
             admin_chat_ids=settings.admin_chat_ids,
+            bot_auto_start=settings.bot_auto_start,
         )
 
         choices = []
@@ -285,20 +291,27 @@ def _handle_telegram_bot_menu() -> None:
 
                 cmd = [sys.executable, "-m", "tunnelmate.bot.telegram_bot"]
                 spawn_background_process(cmd)
+                settings.bot_auto_start = True
+                save_settings(settings)
+
                 with console.status("[bold cyan]Starting Telegram bot in background...[/bold cyan]"):
                     time.sleep(1.0)
                 new_pid = TunnelMateBot.get_running_pid(settings)
                 if new_pid:
                     console.print(f"[bold green]✔ Telegram Bot started in background (PID: {new_pid}).[/bold green]")
+                    console.print("[dim]Auto-restore on reboot: Enabled[/dim]")
                 else:
                     console.print("[bold red]Failed to start bot in background. Verify your token or logs.[/bold red]")
 
             elif bot_action == "🛑 Stop Telegram Bot":
+                settings.bot_auto_start = False
+                save_settings(settings)
                 if pid:
                     with console.status(f"[bold yellow]Stopping Telegram Bot (PID: {pid})...[/bold yellow]"):
                         terminated = terminate_process_by_pid(pid)
                     if terminated:
                         console.print("[bold green]✔ Telegram Bot stopped successfully.[/bold green]")
+                        console.print("[dim]Auto-restore on reboot: Disabled[/dim]")
                     else:
                         console.print("[bold red]Failed to stop Telegram Bot process.[/bold red]")
                 else:
@@ -447,3 +460,59 @@ def _handle_telegram_bot_menu() -> None:
         console.print()
         questionary.press_any_key_to_continue().ask()
 
+
+def _handle_autostart_menu() -> None:
+    """Dedicated interactive submenu for managing system boot autostart."""
+    from rich.panel import Panel
+    from tunnelmate.core.autostart import disable_autostart, enable_autostart, is_autostart_enabled
+
+    while True:
+        console.clear()
+        print_banner()
+
+        enabled, details = is_autostart_enabled()
+        status_text = "[bold green]🟢 ENABLED[/bold green]" if enabled else "[bold red]🔴 DISABLED[/bold red]"
+
+        console.print(
+            Panel(
+                f"Auto-Start on Boot: {status_text}\n"
+                f"Configuration: [white]{details}[/white]\n\n"
+                "[dim]When enabled, the TunnelMate daemon launches automatically on system restart.\n"
+                "All tunnels and Telegram bot active before reboot will automatically resume.[/dim]",
+                title="⚙️ [bold cyan]System Boot Auto-Start[/bold cyan]",
+                border_style="cyan",
+            )
+        )
+
+        choices = []
+        if enabled:
+            choices.append("❌ Disable Auto-Start on Boot")
+        else:
+            choices.append("✔ Enable Auto-Start on Boot")
+        choices.append("🔙 Back to Main Menu")
+
+        action = questionary.select("Select action:", choices=choices).ask()
+        if not action or action == "🔙 Back to Main Menu":
+            break
+
+        if action == "✔ Enable Auto-Start on Boot":
+            with console.status("[bold cyan]Configuring system auto-start for TunnelMate daemon...[/bold cyan]"):
+                ok, msg = enable_autostart()
+            if ok:
+                console.print(f"[bold green]✔ {msg}[/bold green]")
+            else:
+                console.print(f"[bold red]❌ {msg}[/bold red]")
+            console.print()
+            questionary.press_any_key_to_continue().ask()
+
+        elif action == "❌ Disable Auto-Start on Boot":
+            with console.status("[bold yellow]Removing auto-start configuration...[/bold yellow]"):
+                ok, msg = disable_autostart()
+            if ok:
+                console.print(f"[bold yellow]✔ {msg}[/bold yellow]")
+            else:
+                console.print(f"[bold red]❌ {msg}[/bold red]")
+            console.print()
+            questionary.press_any_key_to_continue().ask()
+
+

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/cli/main.py

@@ -42,9 +42,11 @@ app = typer.Typer(
 )
 daemon_app = typer.Typer(name="daemon", help="Manage background daemon service.")
 bot_app = typer.Typer(name="bot", help="Manage Telegram remote management bot.")
+autostart_app = typer.Typer(name="autostart", help="Configure system boot / restart autostart for TunnelMate.")
 
 app.add_typer(daemon_app, name="daemon")
 app.add_typer(bot_app, name="bot")
+app.add_typer(autostart_app, name="autostart")
 
 
 def _get_client() -> TunnelMateClient:
@@ -382,6 +384,46 @@ def cmd_daemon_status():
         console.print(f"[bold yellow]Daemon process exists (PID: {pid}) but IPC is unresponsive.[/bold yellow]")
 
 
+@autostart_app.command(name="enable")
+@daemon_app.command(name="enable")
+def cmd_autostart_enable():
+    """Enable TunnelMate daemon to start automatically on system reboot / boot."""
+    from tunnelmate.core.autostart import enable_autostart
+
+    with console.status("[bold cyan]Configuring system auto-start for TunnelMate daemon...[/bold cyan]"):
+        success, msg = enable_autostart()
+    if success:
+        console.print(f"[bold green]✔ {msg}[/bold green]")
+    else:
+        console.print(f"[bold red]❌ {msg}[/bold red]")
+
+
+@autostart_app.command(name="disable")
+@daemon_app.command(name="disable")
+def cmd_autostart_disable():
+    """Disable TunnelMate daemon from starting automatically on system boot."""
+    from tunnelmate.core.autostart import disable_autostart
+
+    with console.status("[bold yellow]Removing auto-start configuration...[/bold yellow]"):
+        success, msg = disable_autostart()
+    if success:
+        console.print(f"[bold yellow]✔ {msg}[/bold yellow]")
+    else:
+        console.print(f"[bold red]❌ {msg}[/bold red]")
+
+
+@autostart_app.command(name="status")
+def cmd_autostart_status():
+    """Check if TunnelMate daemon is configured to start on boot / restart."""
+    from tunnelmate.core.autostart import is_autostart_enabled
+
+    enabled, msg = is_autostart_enabled()
+    if enabled:
+        console.print(f"[bold green]✔ Auto-Start is ENABLED on boot:[/bold green] {msg}")
+    else:
+        console.print(f"[bold red]❌ Auto-Start is DISABLED on boot:[/bold red] {msg}")
+
+
 # --- Telegram Bot Subcommands ---
 
 
@@ -540,11 +582,12 @@ def cmd_bot_status():
     console.print(f"Telegram Token Configured: {'[bold green]Yes[/bold green]' if has_token else '[bold red]No[/bold red]'}")
     console.print(f"Admin Password Configured: {'[bold green]Yes[/bold green]' if has_pwd else '[bold yellow]No[/bold yellow]'}")
     console.print(f"Admin Whitelisted Chat IDs: {admins_count}")
+    console.print(f"Auto-Restore on Reboot: {'[bold green]Enabled[/bold green]' if settings.bot_auto_start else '[dim]Disabled[/dim]'}")
 
 
 @bot_app.command(name="start")
 def cmd_bot_start():
-    """Launch Telegram Bot in background."""
+    """Launch Telegram Bot in background and enable auto-restore."""
     from tunnelmate.bot.telegram_bot import TunnelMateBot
     settings = load_settings()
     if not settings.telegram_bot_token:
@@ -555,26 +598,39 @@ def cmd_bot_start():
     existing_pid = TunnelMateBot.get_running_pid(settings)
     if existing_pid:
         console.print(f"[bold yellow]Telegram Bot is already running in background (PID: {existing_pid}).[/bold yellow]")
+        if not settings.bot_auto_start:
+            settings.bot_auto_start = True
+            save_settings(settings)
         return
 
     # Spawn bot process in background
     cmd = [sys.executable, "-m", "tunnelmate.bot.telegram_bot"]
     spawn_background_process(cmd)
 
+    # Persist autostart state
+    settings.bot_auto_start = True
+    save_settings(settings)
+
     time.sleep(1.0)
     new_pid = TunnelMateBot.get_running_pid(settings)
     if new_pid:
         console.print(f"[bold green]✔ TunnelMate Telegram bot started in background (PID: {new_pid}).[/bold green]")
+        console.print("[dim]Auto-restore on system restart: Enabled[/dim]")
     else:
         console.print("[bold red]Failed to start bot in background. Try 'tunnelmate bot run' to view logs.[/bold red]")
 
 
 @bot_app.command(name="stop")
 def cmd_bot_stop():
-    """Stop the background Telegram Bot process."""
+    """Stop the background Telegram Bot process and disable auto-restore."""
     from tunnelmate.bot.telegram_bot import TunnelMateBot
     settings = load_settings()
     pid = TunnelMateBot.get_running_pid(settings)
+
+    # Set bot_auto_start to False
+    settings.bot_auto_start = False
+    save_settings(settings)
+
     if not pid:
         console.print("[dim]Telegram Bot is not currently running.[/dim]")
         return

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/config.py

@@ -34,6 +34,7 @@ class Settings(BaseModel):
     admin_password_salt: Optional[str] = None
     admin_chat_ids: List[int] = Field(default_factory=list)
     allow_public_subscribers: bool = True
+    bot_auto_start: bool = False
 
     # Supervision & Automation
     health_check_interval: int = 60  # seconds

tunnelmate_cli-1.0.4/tunnelmate/core/autostart.py

@@ -0,0 +1,283 @@
+"""Cross-platform system boot and reboot autostart management for TunnelMate daemon."""
+
+from __future__ import annotations
+
+import getpass
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Tuple
+
+
+def _get_daemon_exec_cmd() -> str:
+    """Return the optimal command string to execute the daemon."""
+    which_tm = shutil.which("tunnelmate")
+    if which_tm:
+        return f"{which_tm} daemon run"
+    return f"{sys.executable} -m tunnelmate.daemon.service"
+
+
+def is_autostart_enabled() -> Tuple[bool, str]:
+    """Check if TunnelMate daemon is configured to start on system boot."""
+    if sys.platform == "win32":
+        try:
+            import winreg
+
+            key = winreg.OpenKey(
+                winreg.HKEY_CURRENT_USER,
+                r"Software\Microsoft\Windows\CurrentVersion\Run",
+                0,
+                winreg.KEY_READ,
+            )
+            try:
+                val, _ = winreg.QueryValueEx(key, "TunnelMateDaemon")
+                return True, f"Windows Registry Run key configured: {val}"
+            finally:
+                winreg.CloseKey(key)
+        except OSError:
+            pass
+
+        # Check schtasks
+        try:
+            res = subprocess.run(
+                ["schtasks", "/Query", "/TN", "TunnelMateDaemon"],
+                capture_output=True,
+                text=True,
+            )
+            if res.returncode == 0:
+                return True, "Windows Scheduled Task 'TunnelMateDaemon' active"
+        except Exception:
+            pass
+
+        return False, "Autostart is not configured on Windows."
+
+    else:
+        # Linux / Unix
+        if shutil.which("systemctl"):
+            try:
+                res = subprocess.run(
+                    ["systemctl", "--user", "is-enabled", "tunnelmate-daemon.service"],
+                    capture_output=True,
+                    text=True,
+                )
+                if res.returncode == 0 and "enabled" in res.stdout.lower():
+                    return True, "systemd user service 'tunnelmate-daemon' is enabled"
+            except Exception:
+                pass
+
+        # Check crontab
+        if shutil.which("crontab"):
+            try:
+                res = subprocess.run(["crontab", "-l"], capture_output=True, text=True)
+                if res.returncode == 0 and "@reboot" in res.stdout and "tunnelmate" in res.stdout:
+                    return True, "Cron @reboot entry configured"
+            except Exception:
+                pass
+
+        return False, "Autostart is not enabled on Linux."
+
+
+def enable_autostart() -> Tuple[bool, str]:
+    """Configure system to start TunnelMate daemon automatically on boot/restart."""
+    exec_cmd = _get_daemon_exec_cmd()
+
+    if sys.platform == "win32":
+        details = []
+        # 1. Register in HKCU Run Key
+        try:
+            import winreg
+
+            key = winreg.OpenKey(
+                winreg.HKEY_CURRENT_USER,
+                r"Software\Microsoft\Windows\CurrentVersion\Run",
+                0,
+                winreg.KEY_SET_VALUE,
+            )
+            try:
+                # Use pythonw if available for windowless execution on Windows
+                pythonw = Path(sys.executable).parent / "pythonw.exe"
+                run_target = (
+                    f'"{pythonw}" -m tunnelmate.daemon.service'
+                    if pythonw.exists()
+                    else f'"{sys.executable}" -m tunnelmate.daemon.service'
+                )
+                winreg.SetValueEx(key, "TunnelMateDaemon", 0, winreg.REG_SZ, run_target)
+                details.append("Windows Registry Run key added")
+            finally:
+                winreg.CloseKey(key)
+        except Exception as e:
+            details.append(f"Registry error: {e}")
+
+        # 2. Add Task Scheduler task
+        try:
+            cmd = [
+                "schtasks",
+                "/Create",
+                "/TN",
+                "TunnelMateDaemon",
+                "/TR",
+                f'"{sys.executable}" -m tunnelmate.daemon.service',
+                "/SC",
+                "ONLOGON",
+                "/F",
+            ]
+            res = subprocess.run(cmd, capture_output=True, text=True)
+            if res.returncode == 0:
+                details.append("Scheduled Task 'TunnelMateDaemon' created")
+        except Exception:
+            pass
+
+        return True, f"Auto-start successfully enabled on Windows ({'; '.join(details)})."
+
+    else:
+        # Linux / Unix
+        systemd_configured = False
+        linger_configured = False
+        cron_configured = False
+
+        if shutil.which("systemctl"):
+            try:
+                user_unit_dir = Path.home() / ".config" / "systemd" / "user"
+                user_unit_dir.mkdir(parents=True, exist_ok=True)
+                service_file = user_unit_dir / "tunnelmate-daemon.service"
+
+                unit_content = f"""[Unit]
+Description=TunnelMate Cloudflare Quick Tunnel Daemon
+Documentation=https://github.com/tunnelmate/tunnelmate
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart={exec_cmd}
+Restart=always
+RestartSec=5s
+Environment="PYTHONUNBUFFERED=1"
+
+[Install]
+WantedBy=default.target
+"""
+                service_file.write_text(unit_content, encoding="utf-8")
+
+                subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+                res_enable = subprocess.run(
+                    ["systemctl", "--user", "enable", "tunnelmate-daemon.service"],
+                    capture_output=True,
+                    text=True,
+                )
+                if res_enable.returncode == 0:
+                    systemd_configured = True
+                    # Also start now if stopped
+                    subprocess.run(
+                        ["systemctl", "--user", "start", "tunnelmate-daemon.service"],
+                        capture_output=True,
+                    )
+            except Exception:
+                pass
+
+        # Configure user lingering so user service boots even before manual login
+        if shutil.which("loginctl"):
+            try:
+                username = getpass.getuser()
+                res_linger = subprocess.run(
+                    ["loginctl", "enable-linger", username],
+                    capture_output=True,
+                    text=True,
+                )
+                if res_linger.returncode == 0:
+                    linger_configured = True
+            except Exception:
+                pass
+
+        # Fallback / supplementary crontab @reboot entry
+        if shutil.which("crontab"):
+            try:
+                res_cron = subprocess.run(["crontab", "-l"], capture_output=True, text=True)
+                existing = res_cron.stdout if res_cron.returncode == 0 else ""
+                cron_line = f"@reboot {exec_cmd} >/dev/null 2>&1"
+                if cron_line not in existing:
+                    new_cron = (existing.strip() + f"\n{cron_line}\n").strip() + "\n"
+                    proc = subprocess.Popen(["crontab", "-"], stdin=subprocess.PIPE)
+                    proc.communicate(new_cron.encode("utf-8"))
+                    if proc.returncode == 0:
+                        cron_configured = True
+            except Exception:
+                pass
+
+        msgs = []
+        if systemd_configured:
+            msgs.append("systemd user service enabled")
+        if linger_configured:
+            msgs.append("loginctl lingering enabled for boot persistence")
+        if cron_configured:
+            msgs.append("@reboot cron schedule registered")
+
+        if msgs:
+            return True, f"Auto-start successfully enabled: {', '.join(msgs)}."
+        return False, "Failed to register autostart via systemd or crontab."
+
+
+def disable_autostart() -> Tuple[bool, str]:
+    """Remove TunnelMate daemon from system boot / restart autostart."""
+    if sys.platform == "win32":
+        details = []
+        try:
+            import winreg
+
+            key = winreg.OpenKey(
+                winreg.HKEY_CURRENT_USER,
+                r"Software\Microsoft\Windows\CurrentVersion\Run",
+                0,
+                winreg.KEY_SET_VALUE,
+            )
+            try:
+                winreg.DeleteValue(key, "TunnelMateDaemon")
+                details.append("Registry Run key removed")
+            finally:
+                winreg.CloseKey(key)
+        except OSError:
+            pass
+
+        try:
+            subprocess.run(
+                ["schtasks", "/Delete", "/TN", "TunnelMateDaemon", "/F"],
+                capture_output=True,
+            )
+            details.append("Scheduled task removed")
+        except Exception:
+            pass
+
+        return True, "Auto-start disabled on Windows."
+
+    else:
+        # Linux
+        details = []
+        if shutil.which("systemctl"):
+            try:
+                subprocess.run(
+                    ["systemctl", "--user", "disable", "tunnelmate-daemon.service"],
+                    capture_output=True,
+                )
+                subprocess.run(
+                    ["systemctl", "--user", "stop", "tunnelmate-daemon.service"],
+                    capture_output=True,
+                )
+                details.append("systemd user service disabled")
+            except Exception:
+                pass
+
+        if shutil.which("crontab"):
+            try:
+                res_cron = subprocess.run(["crontab", "-l"], capture_output=True, text=True)
+                if res_cron.returncode == 0 and "tunnelmate" in res_cron.stdout:
+                    lines = [l for l in res_cron.stdout.splitlines() if "tunnelmate" not in l]
+                    new_cron = "\n".join(lines).strip() + "\n" if lines else ""
+                    proc = subprocess.Popen(["crontab", "-"], stdin=subprocess.PIPE)
+                    proc.communicate(new_cron.encode("utf-8"))
+                    details.append("crontab entry removed")
+            except Exception:
+                pass
+
+        return True, f"Auto-start disabled ({', '.join(details) if details else 'None'})."

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate/daemon/service.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import Optional
 
 from tunnelmate.config import Settings, load_settings
-from tunnelmate.core.process import is_pid_alive
+from tunnelmate.core.process import is_pid_alive, spawn_background_process
 from tunnelmate.core.supervisor import TunnelSupervisor
 from tunnelmate.daemon.server import DaemonIPCServer
 from tunnelmate.db.repository import Repository
@@ -66,6 +66,11 @@ class DaemonService:
         while not self._stop_event.is_set():
             try:
                 await asyncio.sleep(interval)
+                # Keep settings synced with disk (e.g., bot_auto_start changes)
+                try:
+                    self.settings = load_settings()
+                except Exception:
+                    pass
                 tunnels = await asyncio.to_thread(self.supervisor.list_tunnels)
                 for t in tunnels:
                     if t.status.value == "running":
@@ -73,6 +78,17 @@ class DaemonService:
                             await asyncio.to_thread(self.supervisor.check_health, t.id)
                         except Exception as e:
                             logger.debug("Health check failed for %s: %s", t.name, e)
+
+                # Auto-recover Telegram Bot if bot_auto_start is True and bot process exited
+                if self.settings.bot_auto_start and self.settings.telegram_bot_token:
+                    from tunnelmate.bot.telegram_bot import TunnelMateBot
+                    if not TunnelMateBot.get_running_pid(self.settings):
+                        logger.info("Telegram Bot was active but process exited. Auto-recovering...")
+                        try:
+                            cmd = [sys.executable, "-m", "tunnelmate.bot.telegram_bot"]
+                            spawn_background_process(cmd)
+                        except Exception as e:
+                            logger.debug("Could not recover Telegram Bot: %s", e)
             except asyncio.CancelledError:
                 break
             except Exception as e:
@@ -102,16 +118,28 @@ class DaemonService:
         # Start periodic health task
         self._health_task = asyncio.create_task(self._health_loop())
 
-        # Auto-restart tunnels marked as running previously if needed
+        # Auto-restart tunnels marked as running previously
         try:
             tunnels = await asyncio.to_thread(self.supervisor.list_tunnels)
             for t in tunnels:
-                if t.auto_restart and t.status.value == "running":
+                if t.status.value in ("running", "starting", "restarting"):
                     logger.info("Restoring previously active tunnel: %s", t.name)
                     asyncio.create_task(asyncio.to_thread(self.supervisor.start_tunnel, t.id))
         except Exception as e:
             logger.warning("Could not restore previous tunnels: %s", e)
 
+        # Auto-restore Telegram Bot if it was previously active
+        if self.settings.bot_auto_start and self.settings.telegram_bot_token:
+            from tunnelmate.bot.telegram_bot import TunnelMateBot
+            existing_bot_pid = TunnelMateBot.get_running_pid(self.settings)
+            if not existing_bot_pid:
+                logger.info("Restoring previously active Telegram Bot in background...")
+                try:
+                    cmd = [sys.executable, "-m", "tunnelmate.bot.telegram_bot"]
+                    spawn_background_process(cmd)
+                except Exception as e:
+                    logger.warning("Could not auto-restore Telegram Bot: %s", e)
+
         # Wait until stopped
         await self._stop_event.wait()
 

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tunnelmate-cli
-Version: 1.0.2
+Version: 1.0.4
 Summary: Cloudflare Quick Tunnel manager with CLI, Interactive TUI, Daemon IPC, and Telegram Bot
 Author-email: Shashan Lumbhani <lumbhanishashan1510@gmail.com>
 License: MIT

{tunnelmate_cli-1.0.2 → tunnelmate_cli-1.0.4}/tunnelmate_cli.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ tunnelmate/cli/ssh_client.py
 tunnelmate/client/__init__.py
 tunnelmate/client/ipc_client.py
 tunnelmate/core/__init__.py
+tunnelmate/core/autostart.py
 tunnelmate/core/cloudflared.py
 tunnelmate/core/health.py
 tunnelmate/core/models.py

tunnelmate_cli-1.0.2/tests/test_cross_platform.py

@@ -1,36 +0,0 @@
-"""Tests for cross-platform process management and Windows/Linux compatibility."""
-
-import os
-import sys
-from pathlib import Path
-from tunnelmate.core.process import is_pid_alive, spawn_background_process, terminate_process_by_pid
-from tunnelmate.core.cloudflared import find_cloudflared
-from tunnelmate.cli.ssh_client import clean_ssh_target
-
-
-def test_is_pid_alive():
-    # Current process must be alive
-    assert is_pid_alive(os.getpid()) is True
-    # Non-existent PID must not be alive
-    assert is_pid_alive(99999999) is False
-    assert is_pid_alive(-1) is False
-
-
-def test_spawn_and_terminate_process():
-    # Launch a short-lived python background sleep process
-    cmd = [sys.executable, "-c", "import time; time.sleep(10)"]
-    proc = spawn_background_process(cmd)
-    pid = proc.pid
-    assert pid is not None
-    assert is_pid_alive(pid) is True
-
-    # Terminate process safely using cross-platform helper
-    terminated = terminate_process_by_pid(pid, timeout=3.0)
-    assert terminated is True
-    assert is_pid_alive(pid) is False
-
-
-def test_clean_ssh_target_windows_formats():
-    assert clean_ssh_target("shashan@subjective.trycloudflare.com") == "shashan@subjective.trycloudflare.com"
-    assert clean_ssh_target("shashan@https://subjective.trycloudflare.com/") == "shashan@subjective.trycloudflare.com"
-    assert clean_ssh_target("https://subjective.trycloudflare.com:22") == "subjective.trycloudflare.com"