vssh 3.6.1__tar.gz → 3.6.6__tar.gz

{vssh-3.6.1/vssh.egg-info → vssh-3.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vssh
-Version: 3.6.1
+Version: 3.6.6
 Summary: Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server
 Author-email: MeshPOP <mpop@mpop.dev>
 License: MIT

{vssh-3.6.1 → vssh-3.6.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vssh"
-version = "3.6.1"
+version = "3.6.6"
 description = "Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server"
 readme = "README.md"
 license = {text = "MIT"}

{vssh-3.6.1 → vssh-3.6.6/vssh.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vssh
-Version: 3.6.1
+Version: 3.6.6
 Summary: Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server
 Author-email: MeshPOP <mpop@mpop.dev>
 License: MIT

{vssh-3.6.1 → vssh-3.6.6}/vssh.py

@@ -144,14 +144,31 @@ def vssh_connect(host: str, timeout: float = 5.0) -> socket.socket:
             del _FAILOVER_ACTIVE[host]
 
     # Primary: try Wire VPN IP
+    # First attempt: 2s fast path
+    # If timeout (cold WireGuard peer re-handshake), retry once with longer timeout
+    _wire_refused = False
     try:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(min(timeout, 2.0))  # 2s: enough for WireGuard handshake
+        sock.settimeout(min(timeout, 2.0))  # 2s: fast path
         sock.connect((host, PORT))
-        sock.settimeout(timeout)  # Restore full timeout for I/O
+        sock.settimeout(timeout)
         return sock
-    except (ConnectionRefusedError, ConnectionError, OSError, socket.timeout):
-        pass  # Wire failed, try Tailscale
+    except ConnectionRefusedError:
+        _wire_refused = True  # Port closed — no point retrying
+    except (ConnectionError, OSError, socket.timeout):
+        pass  # Timeout — WireGuard may be re-handshaking, retry once
+
+    if not _wire_refused:
+        # Retry: wait 1s for WireGuard handshake to complete, then retry
+        time.sleep(1.0)
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(min(timeout, 5.0))  # 5s: handshake should be done by now
+            sock.connect((host, PORT))
+            sock.settimeout(timeout)
+            return sock
+        except (ConnectionRefusedError, ConnectionError, OSError, socket.timeout):
+            pass  # Wire truly failed, fall through to Tailscale
 
     # Fallback: try Tailscale IP
     ts_ip = TAILSCALE_MAP.get(host)
@@ -515,23 +532,26 @@ _name_cache = {}  # name -> vpn_ip
 _name_cache_time = 0
 
 def resolve_name(host: str) -> str:
-    """Resolve server name to VPN IP via Wire VPN /peers API (standalone)"""
+    """Resolve server name to VPN IP via Wire VPN /peers API (coordinator-first)
+
+    Priority:
+      1. Fresh in-memory cache (< 60s) — avoids repeated network calls
+      2. Wire coordinator /peers — source of truth (IPs change when nodes move)
+      3. ~/.vssh/config static mapping — fallback when coordinator unreachable
+    """
     global _name_cache, _name_cache_time
     # Strip user@ prefix
     if '@' in host:
         host = host.split('@', 1)[1]
     if not host or host[0].isdigit():
         return host
-    # 1. Check ~/.vssh/config local mapping (instant, no network)
-    if host in VSSH_CONFIG:
-        return VSSH_CONFIG[host]
-    # Use cache if fresh (< 60s)
+    # 1. Use fresh cache — coordinator already queried recently
     if host in _name_cache and time.time() - _name_cache_time < 60:
         return _name_cache[host]
-    # Query Wire VPN server
+    # 2. Query Wire coordinator (source of truth — IPs change when nodes move)
+    import urllib.request
     for srv_ip in WIRE_SERVERS:
         try:
-            import urllib.request
             req = urllib.request.Request(f"http://{srv_ip}:8790/peers")
             with urllib.request.urlopen(req, timeout=3) as resp:
                 data = json.loads(resp.read())
@@ -544,9 +564,12 @@ def resolve_name(host: str) -> str:
                 _name_cache_time = time.time()
                 if host in _name_cache:
                     return _name_cache[host]
-                break  # got peers, just no match
+                break  # got peers from coordinator, just no match for this host
         except (OSError, ValueError, TimeoutError):
             continue
+    # 3. Fall back to static config (useful when all coordinators unreachable)
+    if host in VSSH_CONFIG:
+        return VSSH_CONFIG[host]
     return host
 
 
@@ -3860,6 +3883,65 @@ Env: VSSH_SECRET
             print(f'  Done: {result["ok"]} ok, {result["skip"]} skip, {result["fail"]} fail')
 
         sys.exit(0 if result['fail'] == 0 else 1)
+    elif cmd == 'up':
+        # Start vssh daemon (systemd or direct)
+        import subprocess as _sp, os as _os
+        if _os.path.exists("/run/systemd/system"):
+            r = _sp.run(["systemctl", "start", "vssh"], capture_output=True)
+            if r.returncode == 0:
+                print("vssh started")
+            else:
+                print(r.stderr.decode().strip() or "Failed to start vssh via systemctl")
+        else:
+            print("Starting vssh daemon...")
+            server()
+    elif cmd == 'down':
+        # Stop vssh daemon
+        import subprocess as _sp, os as _os
+        if _os.path.exists("/run/systemd/system"):
+            r = _sp.run(["systemctl", "stop", "vssh"], capture_output=True)
+            if r.returncode == 0:
+                print("vssh stopped")
+            else:
+                print(r.stderr.decode().strip() or "Failed to stop vssh via systemctl")
+        else:
+            import signal as _sig
+            import glob as _glob
+            killed = 0
+            for _f in _glob.glob("/tmp/vssh_*.pid") + _glob.glob("/var/run/vssh.pid"):
+                try:
+                    _pid = int(open(_f).read().strip())
+                    _os.kill(_pid, _sig.SIGTERM)
+                    _os.unlink(_f)
+                    killed += 1
+                except (ValueError, OSError):
+                    pass
+            if killed:
+                print(f"vssh stopped ({killed} process(es))")
+            else:
+                import subprocess as _sp2
+                r = _sp2.run(["pkill", "-f", "vssh.*server"], capture_output=True)
+                print("vssh stopped" if r.returncode == 0 else "vssh was not running")
+    elif cmd == 'restart':
+        # Restart vssh daemon
+        import subprocess as _sp, os as _os
+        if _os.path.exists("/run/systemd/system"):
+            r = _sp.run(["systemctl", "restart", "vssh"], capture_output=True)
+            if r.returncode == 0:
+                print("vssh restarted")
+            else:
+                print(r.stderr.decode().strip() or "Failed to restart vssh via systemctl")
+        else:
+            import signal as _sig, glob as _glob
+            for _f in _glob.glob("/tmp/vssh_*.pid") + _glob.glob("/var/run/vssh.pid"):
+                try:
+                    _pid = int(open(_f).read().strip())
+                    _os.kill(_pid, _sig.SIGTERM)
+                    _os.unlink(_f)
+                except (ValueError, OSError):
+                    pass
+            print("Restarting vssh daemon...")
+            server()
     elif cmd == 'server':
         server()
     elif cmd == 'install':
@@ -3873,15 +3955,39 @@ Env: VSSH_SECRET
         import socket as _sock
         import concurrent.futures
         full_mode = '--full' in args or '-f' in args
-        # Use vssh standalone config (no mpop dependency)
+        # Build server list: coordinator first (source of truth), config as supplement
         _servers = {}
+        import urllib.request as _ureq
+        for _srv_ip in WIRE_SERVERS:
+            try:
+                with _ureq.urlopen(f"http://{_srv_ip}:8790/peers", timeout=3) as _r:
+                    _peers = json.loads(_r.read()).get("peers", [])
+                    for _p in _peers:
+                        _nn = _p.get("node_name", "")
+                        _vip = _p.get("vpn_ip", "")
+                        if _nn and _vip:
+                            _servers[_nn] = _vip
+                    break
+            except (OSError, ValueError, TimeoutError):
+                continue
+        # Detect local node by trying to bind to each VPN IP
+        def _is_local_ip(ip):
+            try:
+                _s = _sock.socket(_sock.AF_INET, _sock.SOCK_DGRAM)
+                _s.bind((ip, 0)); _s.close(); return True
+            except OSError:
+                return False
+        _my_vpn_ip = next((ip for ip in _servers.values() if _is_local_ip(ip)), "")
+        # Also include any config entries not in coordinator (offline/static nodes)
         for k, v in VSSH_CONFIG.items():
-            if k in ('SECRET','SSH_PORT','SCP_PORT'): continue
-            if v and v[0].isdigit():
+            if k in ('SECRET', 'SSH_PORT', 'SCP_PORT'): continue
+            if v and v[0].isdigit() and k not in _servers:
                 _servers[k] = v
 
         def _check_node(name, ip):
             """Check a single node — connect + optional INFO query (Wire VPN → Tailscale fallback)"""
+            if ip == _my_vpn_ip:
+                return {'name': name, 'ip': ip, 'online': True, 'latency': 0, 'local': True}
             result = {'name': name, 'ip': ip, 'online': False, 'latency': 0}
             try:
                 t0 = time.time()
@@ -3993,6 +4099,8 @@ Env: VSSH_SECRET
                     cores = d.get('cores', '')
                     cores_str = f"{cores}c" if cores else ""
                     print(f"  {r['name']:6s} ● {r['latency']:4.0f}ms  mem={mem_str:>12s}  load={load_str:>5s}  up={up_str:>7s}  {cores_str}")
+                elif r.get('local'):
+                    print(f"  {r['name']:6s} {r['ip']:18s} ● online  (local)")
                 else:
                     print(f"  {r['name']:6s} {r['ip']:18s} ● online  ({r['latency']:.0f}ms)")
             else: