vssh 3.3.1__tar.gz → 3.3.4__tar.gz

{vssh-3.3.1/vssh.egg-info → vssh-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vssh
-Version: 3.3.1
+Version: 3.3.4
 Summary: Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server
 Author-email: MeshPOP <mpop@mpop.dev>
 License: MIT
@@ -41,10 +41,10 @@ pip install vssh
 
 ```bash
 # Execute remote command
-vssh exec v1 "uptime"
+vssh exec relay1 "uptime"
 
 # Transfer file at 50+ MB/s
-vssh put v1 ./deploy.tar.gz /opt/deploy.tar.gz
+vssh put relay1 ./deploy.tar.gz /opt/deploy.tar.gz
 
 # Check connection status
 vssh status

{vssh-3.3.1 → vssh-3.3.4}/README.md

@@ -18,10 +18,10 @@ pip install vssh
 
 ```bash
 # Execute remote command
-vssh exec v1 "uptime"
+vssh exec relay1 "uptime"
 
 # Transfer file at 50+ MB/s
-vssh put v1 ./deploy.tar.gz /opt/deploy.tar.gz
+vssh put relay1 ./deploy.tar.gz /opt/deploy.tar.gz
 
 # Check connection status
 vssh status

{vssh-3.3.1 → vssh-3.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vssh"
-version = "3.3.1"
+version = "3.3.4"
 description = "Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server"
 readme = "README.md"
 license = {text = "MIT"}
@@ -34,5 +34,8 @@ vssh-mcp = "vssh_mcp_server:main"
 Homepage = "https://github.com/meshpop/vssh"
 Repository = "https://github.com/meshpop/vssh"
 
+[project.entry-points."meshpop.mcp"]
+vssh = "vssh_mcp_server"
+
 [tool.setuptools]
-py-modules = ["vssh", "vssh_p2p", "vssh_p2p_fast", "vssh_quic", "vssh_mcp_server"]
+py-modules = ["vssh", "vssh_p2p", "vssh_mcp_server"]

{vssh-3.3.1 → vssh-3.3.4/vssh.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vssh
-Version: 3.3.1
+Version: 3.3.4
 Summary: Secure SSH/SCP tool with Tailscale failover, P2P transport, and MCP server
 Author-email: MeshPOP <mpop@mpop.dev>
 License: MIT
@@ -41,10 +41,10 @@ pip install vssh
 
 ```bash
 # Execute remote command
-vssh exec v1 "uptime"
+vssh exec relay1 "uptime"
 
 # Transfer file at 50+ MB/s
-vssh put v1 ./deploy.tar.gz /opt/deploy.tar.gz
+vssh put relay1 ./deploy.tar.gz /opt/deploy.tar.gz
 
 # Check connection status
 vssh status

{vssh-3.3.1 → vssh-3.3.4}/vssh.egg-info/SOURCES.txt

@@ -4,8 +4,6 @@ pyproject.toml
 vssh.py
 vssh_mcp_server.py
 vssh_p2p.py
-vssh_p2p_fast.py
-vssh_quic.py
 vssh.egg-info/PKG-INFO
 vssh.egg-info/SOURCES.txt
 vssh.egg-info/dependency_links.txt

{vssh-3.3.1 → vssh-3.3.4}/vssh.egg-info/entry_points.txt

@@ -1,3 +1,6 @@
 [console_scripts]
 vssh = vssh:main
 vssh-mcp = vssh_mcp_server:main
+
+[meshpop.mcp]
+vssh = vssh_mcp_server

{vssh-3.3.1 → vssh-3.3.4}/vssh.egg-info/top_level.txt

@@ -1,5 +1,3 @@
 vssh
 vssh_mcp_server
 vssh_p2p
-vssh_p2p_fast
-vssh_quic

{vssh-3.3.1 → vssh-3.3.4}/vssh.py

@@ -68,7 +68,7 @@ def _load_tailscale_map() -> dict:
                 if len(parts) >= 2:
                     ts_map[parts[0]] = parts[1]  # wire_ip tailscale_ip
         except (OSError, ValueError) as e:
-            pass  # TODO: log error
+            pass  # e silenced
 
     return ts_map
 
@@ -103,7 +103,7 @@ def vssh_connect(host: str, timeout: float = 5.0) -> socket.socket:
         sock.connect((host, PORT))
         return sock
     except (ConnectionRefusedError, ConnectionError, OSError, socket.timeout) as wire_err:
-        pass  # TODO: log error
+        pass  # wire_err silenced
 
     # Fallback: try Tailscale IP
     ts_ip = TAILSCALE_MAP.get(host)
@@ -380,7 +380,7 @@ def get_public_ip() -> str:
             except (urllib.error.URLError, OSError):
                 continue
     except Exception as e:
-        pass  # TODO: log error
+        pass  # e silenced
     return ''
 
 def get_network_info_local() -> dict:
@@ -435,7 +435,7 @@ def is_safe_network(host: str) -> Tuple[bool, str]:
             if 16 <= second <= 31:
                 return True, "lan"
         except (ValueError, IndexError) as e:
-            pass  # TODO: log error
+            pass  # e silenced
 
     # Everything else is public IP - UNSAFE!
     return False, "public_ip_unencrypted"
@@ -499,7 +499,7 @@ def resolve_name(host: str) -> str:
                 if host in _name_cache:
                     return _name_cache[host]
                 break  # got peers, just no match
-        except (OSError, subprocess.SubprocessError):
+        except (OSError, ValueError, TimeoutError):
             continue
     return host
 
@@ -748,7 +748,7 @@ def _rpc_get_logs(payload: dict) -> dict:
             )
             return {'service': service, 'lines': r.stdout.strip().split('\n')}
         except (subprocess.SubprocessError, OSError) as e:
-            pass  # TODO: log error
+            pass  # e silenced
 
     path = log_paths.get(service)
     if path and os.path.exists(path):
@@ -2421,11 +2421,11 @@ def pty_session(host: str, name: str = ''):
                         sys.stdout.buffer.write(data)
                         sys.stdout.buffer.flush()
                     except (BlockingIOError) as e:
-                        pass  # TODO: log error
+                        pass  # e silenced
                     except (EOFError, ConnectionError):
                         raise EOFError
     except (EOFError, KeyboardInterrupt, ConnectionError, BrokenPipeError) as e:
-        pass  # TODO: log error
+        pass  # e silenced
     finally:
         # Restore terminal
         if old_settings:
@@ -2588,7 +2588,7 @@ class VsshSession:
                 self.sock.sendall(f"CLOSE:{self.session_id}\n".encode())
                 self.sock.recv(32)  # CLOSE_OK
             except OSError as e:
-                pass  # TODO: log error
+                pass  # e silenced
             finally:
                 self.sock.close()
                 self.sock = None
@@ -3213,7 +3213,7 @@ def server():
                                 try:
                                     payload = json.loads(payload_data.decode())
                                 except (json.JSONDecodeError, ValueError, UnicodeDecodeError) as e:
-                                    pass  # TODO: log error
+                                    pass  # e silenced
 
                             result = handle_rpc(method, payload, sender_ip=addr[0])
                             conn.sendall(f'RPC_RESULT:{len(result)}\n'.encode())
@@ -3281,6 +3281,14 @@ def server():
 
 def main():
     args = sys.argv[1:]
+    # Handle --version and --help flags
+    if args and args[0] in ("--version", "-v", "-V"):
+        try:
+            from importlib.metadata import version as _v
+            print(f"vssh v{_v('vssh')}")
+        except Exception:
+            print("vssh v3.3.2")
+        return
     if not args:
         print('''vssh v3 - Distributed command & file transport daemon for server meshes
 
@@ -3469,7 +3477,7 @@ Env: VSSH_SECRET
             try:
                 days = int(args[1])
             except (ValueError, TypeError) as e:
-                pass  # TODO: log error
+                pass  # e silenced
         stats = get_transfer_stats(days)
         print(f'Transfer Statistics (last {days} days)')
         print(f'  Total transfers: {stats["total"]}')
@@ -3634,7 +3642,7 @@ Env: VSSH_SECRET
                         try:
                             result['info'] = json.loads(buf.decode())
                         except (json.JSONDecodeError, ValueError, UnicodeDecodeError) as e:
-                            pass  # TODO: log error
+                            pass  # e silenced
                 s.close()
             except OSError:
                 pass  # safe to ignore
@@ -3723,7 +3731,7 @@ Env: VSSH_SECRET
                 print(f"  {r['name']:6s} {r['ip']:18s} ○ offline")
         print(f"\nTotal: {online}/{total} online")
     else:
-        # Unknown command -> try as PTY session shortcut (vssh g3 = vssh session g3)
+        # Unknown command -> try as PTY session shortcut (vssh node3 = vssh session node3)
         host = resolve_name(cmd)
         rc = pty_session(host, cmd)
         if rc != 0:

{vssh-3.3.1 → vssh-3.3.4}/vssh_mcp_server.py

@@ -237,9 +237,12 @@ def vssh_download(ip: str, remote_path: str, local_path: str) -> dict:
         if not resp.startswith(b'OK:'):
             return {"error": resp.decode()}
 
-        # Parse size
-        parts = resp.decode().split(':')
-        size = int(parts[1])
+        # Parse size — format: OK:<size>\n or OK:<size>:<checksum>\n
+        try:
+            parts = resp.decode().split(':')
+            size = int(parts[1].strip())
+        except (IndexError, ValueError) as parse_err:
+            return {"error": f"Unexpected server response: {resp[:64]!r} ({parse_err})"}
 
         # Receive file data
         start = time.time()
@@ -253,8 +256,9 @@ def vssh_download(ip: str, remote_path: str, local_path: str) -> dict:
         elapsed = time.time() - start
         sock.close()
 
-        # Save file
-        os.makedirs(os.path.dirname(local_path) or '.', exist_ok=True)
+        # Save file — ensure parent dir exists for bare filenames too
+        local_dir = os.path.dirname(os.path.abspath(local_path))
+        os.makedirs(local_dir, exist_ok=True)
         with open(local_path, 'wb') as f:
             f.write(data)
 
@@ -342,28 +346,57 @@ def tool_vssh_get(server: str, remote_path: str, local_path: str):
     return vssh_download(ip, remote_path, local_path)
 
 def tool_vssh_sync(source: str, dest: str, path: str):
-    """Sync directory between servers"""
+    """Sync directory from source server to dest server via local relay"""
     servers = get_servers()
 
-    if source not in servers or dest not in servers:
-        return {"error": "Unknown server(s)"}
+    if source not in servers:
+        return {"error": f"Unknown source server: {source}"}
+    if dest not in servers:
+        return {"error": f"Unknown dest server: {dest}"}
+
+    src_ip = servers[source].get("ip", "").strip()
+    dst_ip = servers[dest].get("ip", "").strip()
+
+    if not src_ip:
+        return {"error": f"No IP configured for source server: {source}"}
+    if not dst_ip:
+        return {"error": f"No IP configured for dest server: {dest}"}
 
     # Get file list from source
-    src_ip = servers[source].get("ip", "")
     files_output = vssh_exec_cmd(src_ip, f"find {path} -type f 2>/dev/null | head -100")
-
     if files_output.startswith("Error"):
-        return {"error": files_output}
-
-    files = [f for f in files_output.split('\n') if f.strip()]
+        return {"error": f"Cannot list files on {source}: {files_output}"}
+
+    files = [f.strip() for f in files_output.split("\n") if f.strip()]
+    if not files:
+        return {"source": source, "dest": dest, "path": path,
+                "synced": 0, "message": "No files found at path"}
+
+    # Relay: download each file from source, upload to dest
+    import tempfile
+    synced, failed = [], []
+    with tempfile.TemporaryDirectory(prefix="vssh_sync_") as tmpdir:
+        for remote_file in files:
+            fname = os.path.basename(remote_file)
+            local_tmp = os.path.join(tmpdir, fname)
+            dl = vssh_download(src_ip, remote_file, local_tmp)
+            if "error" in dl:
+                failed.append({"file": remote_file, "error": dl["error"]})
+                continue
+            ul = vssh_upload(dst_ip, local_tmp, remote_file)
+            if "error" in ul:
+                failed.append({"file": remote_file, "error": ul["error"]})
+            else:
+                synced.append(remote_file)
 
     return {
         "source": source,
         "dest": dest,
         "path": path,
-        "files_found": len(files),
-        "files": files[:20],
-        "note": "Use vssh_put for each file to sync"
+        "total_files": len(files),
+        "synced": len(synced),
+        "failed": len(failed),
+        "errors": failed[:10] if failed else []
     }
 
 def tool_vssh_speed_test(server: str, size_mb: int = 10):
@@ -433,41 +466,97 @@ def tool_vssh_p2p_status():
         }
 
 def tool_vssh_tunnel(server: str, local_port: int, remote_port: int, remote_host: str = "localhost"):
-    """Create SSH tunnel (port forwarding)"""
+    """Create SSH tunnel (port forwarding). Launches tunnel in background and returns PID."""
     servers = get_servers()
 
     if server not in servers:
         return {"error": f"Unknown server: {server}"}
 
-    ip = servers[server].get("ip", "")
+    ip = servers[server].get("ip", "").strip()
+    if not ip:
+        return {"error": f"No IP configured for server: {server}"}
 
-    # Check if tunnel already exists
+    user = servers[server].get("user", "root")
+
+    # Check if local port is already in use
     import subprocess
     check = subprocess.run(
         f"lsof -i :{local_port} 2>/dev/null | grep LISTEN",
         shell=True, capture_output=True, text=True
     )
-
     if check.stdout.strip():
+        # Check if it's already our tunnel
+        if ip in check.stdout or server in check.stdout:
+            return {
+                "status": "already_running",
+                "local_port": local_port,
+                "message": f"Tunnel to {server}:{remote_port} already running on localhost:{local_port}"
+            }
         return {
             "status": "port_in_use",
             "local_port": local_port,
-            "message": f"Port {local_port} is already in use"
+            "message": f"Port {local_port} is already in use by another process"
         }
 
-    # Create tunnel command
-    tunnel_cmd = f"ssh -f -N -L {local_port}:{remote_host}:{remote_port} {ip}"
+    # Build SSH tunnel command
+    ssh_args = [
+        "ssh", "-f", "-N",
+        "-o", "StrictHostKeyChecking=no",
+        "-o", "ConnectTimeout=10",
+        "-o", "BatchMode=yes",
+        "-L", f"{local_port}:{remote_host}:{remote_port}",
+        f"{user}@{ip}"
+    ]
+    tunnel_cmd = " ".join(ssh_args)
+
+    # Launch tunnel as background process
+    try:
+        proc = subprocess.Popen(
+            ssh_args,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            start_new_session=True
+        )
+        # Wait briefly to detect immediate failures
+        import time
+        time.sleep(1.5)
+        if proc.poll() is not None:
+            # Process already exited — SSH failed
+            err = proc.stderr.read().decode(errors="replace").strip()
+            return {
+                "status": "failed",
+                "error": f"SSH tunnel failed: {err or 'exited immediately'}",
+                "command": tunnel_cmd,
+                "hint": "Check SSH key auth: ssh-copy-id " + user + "@" + ip
+            }
 
-    return {
-        "status": "ready",
-        "server": server,
-        "local_port": local_port,
-        "remote_host": remote_host,
-        "remote_port": remote_port,
-        "command": tunnel_cmd,
-        "usage": f"Access {remote_host}:{remote_port} on {server} via localhost:{local_port}",
-        "note": "Run the command to create the tunnel. Use 'pkill -f \"ssh.*-L {local_port}\"' to close."
-    }
+        # Verify port is now listening
+        verify = subprocess.run(
+            f"lsof -i :{local_port} 2>/dev/null | grep LISTEN",
+            shell=True, capture_output=True, text=True
+        )
+        listening = bool(verify.stdout.strip())
+
+        return {
+            "status": "running" if listening else "started",
+            "pid": proc.pid,
+            "server": server,
+            "local_port": local_port,
+            "remote_host": remote_host,
+            "remote_port": remote_port,
+            "access": f"localhost:{local_port}",
+            "usage": f"Connect to {remote_host}:{remote_port} on {server} via localhost:{local_port}",
+            "close_cmd": f"kill {proc.pid}  # or: pkill -f \'ssh.*-L {local_port}\'"
+        }
+
+    except FileNotFoundError:
+        return {
+            "status": "no_ssh",
+            "error": "ssh not found — install OpenSSH",
+            "command": tunnel_cmd
+        }
+    except Exception as e:
+        return {"status": "error", "error": str(e), "command": tunnel_cmd}
 
 def tool_vssh_keys():
     """Manage vssh keys and secrets"""
@@ -493,7 +582,7 @@ def tool_vssh_keys():
                     "permissions": oct(os.stat(fpath).st_mode)[-3:]
                 })
 
-    # Check servers with vssh daemon
+    # Check servers with vssh server running
     servers = get_servers()
     keys["servers_with_vssh"] = []
 
@@ -634,7 +723,7 @@ TOOLS = [
     },
     {
         "name": "vssh_tunnel",
-        "description": "Create SSH tunnel (port forwarding) to access remote services locally.",
+        "description": "Create SSH tunnel (port forwarding) to access remote services locally. Launches tunnel in background, returns PID and access URL.",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -758,5 +847,21 @@ def main():
             sys.stderr.write(f"Error: {e}\n")
             break
 
+
+def handle_tool(name: str, arguments: dict) -> str:
+    """Unified MCP compatibility wrapper."""
+    resp = handle_request({
+        "method": "tools/call",
+        "id": 1,
+        "params": {"name": name, "arguments": arguments},
+    })
+    if resp and "result" in resp:
+        content = resp["result"].get("content", [])
+        if content:
+            return content[0].get("text", "{}")
+    if resp and "error" in resp:
+        return json.dumps({"error": resp["error"]})
+    return json.dumps({"error": "no result"})
+
 if __name__ == "__main__":
     main()

{vssh-3.3.1 → vssh-3.3.4}/vssh_p2p.py

@@ -519,9 +519,9 @@ def p2p_tcp_connect(peer_ip: str, peer_port: int, local_port: int,
         return None
 
 def signal_exchange(peer_vpn_ip: str, my_external: tuple, relay_ip: str = None, timeout: int = 30) -> tuple:
-    """Exchange external addresses via relay server (v1)
+    """Exchange external addresses via relay server (relay1)
 
-    Both peers register with v1, then query for each other.
+    Both peers register with relay1, then query for each other.
     Returns peer's (external_ip, external_port, local_port) or (None, None, None)
     """
     import subprocess