Merge branch 'develop' of https://github.com/EvolutionAPI/evo-nexus into develop

DavidsonGomes · DavidsonGomes · commit 4dbfb7f0c6f0 · 2026-04-10T13:16:49.000-03:00
diff --git a/dashboard/backend/routes/terminal.py b/dashboard/backend/routes/terminal.py
@@ -1,13 +1,7 @@
 """Terminal endpoint — WebSocket PTY for real terminal sessions."""
 
 import os
-import pty
-import select
-import signal
-import struct
-import fcntl
-import termios
-import subprocess
+import sys
 import json
 import threading
 import time
@@ -22,6 +16,18 @@
 bp = Blueprint("terminal", __name__)
 sock = Sock()
 
+_WINDOWS = sys.platform == "win32"
+
+if _WINDOWS:
+    from winpty import PtyProcess
+else:
+    import pty
+    import select
+    import signal
+    import struct
+    import fcntl
+    import termios
+
 # Store active sessions: {session_id: {pid, fd}}
 sessions = {}
 session_counter = 0
@@ -94,7 +100,7 @@ def _parse_session_file(filepath, max_lines=20):
 
 
 def _spawn_pty(cmd, cwd):
-    """Spawn a process in a PTY and return (pid, fd)."""
+    """Spawn a process in a PTY and return (pid, fd). Unix only."""
     env = os.environ.copy()
     env["TERM"] = "xterm-256color"
     env["COLUMNS"] = "120"
@@ -109,22 +115,34 @@ def _spawn_pty(cmd, cwd):
 
 
 def _set_winsize(fd, rows, cols):
-    """Set terminal window size."""
+    """Set terminal window size. Unix only."""
     winsize = struct.pack("HHHH", rows, cols, 0, 0)
     fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
 
 
+def _spawn_conpty(cmd, cwd):
+    """Spawn a process in a Windows ConPTY and return a PtyProcess."""
+    env = os.environ.copy()
+    env["TERM"] = "xterm-256color"
+    return PtyProcess.spawn(cmd, cwd=str(cwd), env=env, dimensions=(40, 120))
+
+
 @bp.route("/api/terminal/sessions")
 @login_required
 def list_sessions():
     """List active terminal sessions."""
     result = []
     for sid, info in sessions.items():
-        try:
-            os.kill(info["pid"], 0)  # Check if alive
-            result.append({"id": sid, "cmd": info["cmd"], "alive": True})
-        except OSError:
-            result.append({"id": sid, "cmd": info["cmd"], "alive": False})
+        if _WINDOWS:
+            proc = info.get("process")
+            alive = proc.isalive() if proc else False
+        else:
+            try:
+                os.kill(info["pid"], 0)
+                alive = True
+            except OSError:
+                alive = False
+        result.append({"id": sid, "cmd": info["cmd"], "alive": alive})
     return {"sessions": result}
 
 
@@ -184,15 +202,19 @@ def create_session():
                 return {"error": "Session not found"}, 404
             cmd.extend(["--resume", resume_id])
     elif cmd_type == "shell":
-        cmd = [os.environ.get("SHELL", "/bin/zsh")]
+        cmd = ["cmd.exe"] if _WINDOWS else [os.environ.get("SHELL", "/bin/zsh")]
     else:
         cmd = ["claude", "--dangerously-skip-permissions"]
 
     try:
-        pid, fd = _spawn_pty(cmd, WORKSPACE)
         session_counter += 1
         sid = f"term-{session_counter}"
-        sessions[sid] = {"pid": pid, "fd": fd, "cmd": " ".join(cmd)}
+        if _WINDOWS:
+            proc = _spawn_conpty(cmd, WORKSPACE)
+            sessions[sid] = {"process": proc, "cmd": " ".join(cmd)}
+        else:
+            pid, fd = _spawn_pty(cmd, WORKSPACE)
+            sessions[sid] = {"pid": pid, "fd": fd, "cmd": " ".join(cmd)}
         return {"id": sid, "cmd": " ".join(cmd)}
     except Exception as e:
         return {"error": str(e)}, 500
@@ -206,8 +228,11 @@ def kill_session(session_id):
     if not info:
         return {"error": "Session not found"}, 404
     try:
-        os.kill(info["pid"], signal.SIGTERM)
-        os.close(info["fd"])
+        if _WINDOWS:
+            info["process"].terminate(force=True)
+        else:
+            os.kill(info["pid"], signal.SIGTERM)
+            os.close(info["fd"])
     except OSError:
         pass
     del sessions[session_id]
@@ -231,73 +256,127 @@ def terminal_ws(ws, session_id):
             ws.send(json.dumps({"error": "Session not found"}))
             return
 
-        fd = info["fd"]
-
-        # Set non-blocking
-        import fcntl
-        flags = fcntl.fcntl(fd, fcntl.F_GETFL)
-        fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+        if _WINDOWS:
+            proc = info["process"]
 
-        def read_output():
-            """Read from PTY and send to WebSocket."""
-            while True:
-                try:
-                    r, _, _ = select.select([fd], [], [], 0.1)
-                    if r:
-                        data = os.read(fd, 4096)
+            def read_output():
+                """Read from ConPTY and send to WebSocket."""
+                while True:
+                    try:
+                        if not proc.isalive():
+                            break
+                        data = proc.read(4096)
                         if data:
-                            ws.send(data.decode("utf-8", errors="replace"))
+                            ws.send(data if isinstance(data, str) else data.decode("utf-8", errors="replace"))
                         else:
-                            break
-                except (OSError, EOFError):
-                    break
+                            time.sleep(0.01)
+                    except Exception:
+                        break
+                try:
+                    ws.send("\r\n[Process exited]\r\n")
                 except Exception:
-                    break
+                    pass
+
+            reader = threading.Thread(target=read_output, daemon=True)
+            reader.start()
+
             try:
-                ws.send("\r\n[Process exited]\r\n")
+                while True:
+                    try:
+                        msg = ws.receive(timeout=300)
+                    except Exception:
+                        break
+
+                    if msg is None:
+                        break
+
+                    if isinstance(msg, str) and msg.startswith('{"resize":'):
+                        try:
+                            data = json.loads(msg)
+                            proc.setwinsize(data["resize"]["rows"], data["resize"]["cols"])
+                        except Exception:
+                            pass
+                        continue
+
+                    if isinstance(msg, str) and msg == '{"ping":true}':
+                        try:
+                            ws.send('{"pong":true}')
+                        except Exception:
+                            pass
+                        continue
+
+                    try:
+                        proc.write(msg if isinstance(msg, str) else msg.decode("utf-8"))
+                    except Exception:
+                        break
             except Exception:
                 pass
+            finally:
+                reader.join(timeout=1)
 
-        # Start reader thread
-        reader = threading.Thread(target=read_output, daemon=True)
-        reader.start()
+        else:
+            fd = info["fd"]
+
+            # Set non-blocking
+            import fcntl
+            flags = fcntl.fcntl(fd, fcntl.F_GETFL)
+            fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
 
-        # Main loop: read from WebSocket, write to PTY
-        try:
-            while True:
+            def read_output():
+                """Read from PTY and send to WebSocket."""
+                while True:
+                    try:
+                        r, _, _ = select.select([fd], [], [], 0.1)
+                        if r:
+                            data = os.read(fd, 4096)
+                            if data:
+                                ws.send(data.decode("utf-8", errors="replace"))
+                            else:
+                                break
+                    except (OSError, EOFError):
+                        break
+                    except Exception:
+                        break
                 try:
-                    msg = ws.receive(timeout=300)  # 5 min timeout
+                    ws.send("\r\n[Process exited]\r\n")
                 except Exception:
-                    break
+                    pass
 
-                if msg is None:
-                    break
+            reader = threading.Thread(target=read_output, daemon=True)
+            reader.start()
 
-                # Handle resize messages
-                if isinstance(msg, str) and msg.startswith('{"resize":'):
+            try:
+                while True:
                     try:
-                        data = json.loads(msg)
-                        rows = data["resize"]["rows"]
-                        cols = data["resize"]["cols"]
-                        _set_winsize(fd, rows, cols)
+                        msg = ws.receive(timeout=300)
                     except Exception:
-                        pass
-                    continue
+                        break
+
+                    if msg is None:
+                        break
+
+                    if isinstance(msg, str) and msg.startswith('{"resize":'):
+                        try:
+                            data = json.loads(msg)
+                            rows = data["resize"]["rows"]
+                            cols = data["resize"]["cols"]
+                            _set_winsize(fd, rows, cols)
+                        except Exception:
+                            pass
+                        continue
+
+                    if isinstance(msg, str) and msg == '{"ping":true}':
+                        try:
+                            ws.send('{"pong":true}')
+                        except Exception:
+                            pass
+                        continue
 
-                # Handle ping/keepalive
-                if isinstance(msg, str) and msg == '{"ping":true}':
                     try:
-                        ws.send('{"pong":true}')
-                    except Exception:
-                        pass
-                    continue
-
-                # Write input to PTY
-                try:
-                    os.write(fd, msg.encode("utf-8") if isinstance(msg, str) else msg)
-                except OSError:
-                    break
-        except Exception:
-            pass
-        finally:
-            reader.join(timeout=1)
+                        os.write(fd, msg.encode("utf-8") if isinstance(msg, str) else msg)
+                    except OSError:
+                        break
+            except Exception:
+                pass
+            finally:
+                reader.join(timeout=1)
diff --git a/pyproject.toml b/pyproject.toml
@@ -15,6 +15,7 @@ dependencies = [
     "requests>=2.31",
     "pyyaml>=6.0",
     "flask-sock>=0.7",
+    "pywinpty>=3.0.3; sys_platform == 'win32'",
 ]
 
 [tool.uv]
diff --git a/setup.py b/setup.py
@@ -69,14 +69,22 @@ def check_prerequisites():
         errors.append("node")
 
     # npm
+    npm_cmd = "npm"
     try:
-        result = subprocess.run(["npm", "--version"], capture_output=True, text=True, timeout=5)
-        if result.returncode == 0:
-            print(f"  {GREEN}✓{RESET} npm: {DIM}v{result.stdout.strip()}{RESET}")
-        else:
-            errors.append("npm")
+        result = subprocess.run([npm_cmd, "--version"], capture_output=True, text=True, timeout=5)
+        if result.returncode != 0:
+            raise FileNotFoundError
+        print(f"  {GREEN}✓{RESET} npm: {DIM}v{result.stdout.strip()}{RESET}")
     except (FileNotFoundError, subprocess.TimeoutExpired):
-        errors.append("npm")
+        try:
+            npm_cmd = "npm.cmd"
+            result = subprocess.run([npm_cmd, "--version"], capture_output=True, text=True, timeout=5)
+            if result.returncode == 0:
+                print(f"  {GREEN}✓{RESET} npm: {DIM}v{result.stdout.strip()}{RESET}")
+            else:
+                errors.append("npm")
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            errors.append("npm")
 
     print()
 
@@ -88,8 +96,10 @@ def check_prerequisites():
         if "uv" in errors:
             print(f"    {RED}•{RESET} uv (Python package manager) — {BOLD}https://docs.astral.sh/uv/{RESET}")
             print(f"      {DIM}curl -LsSf https://astral.sh/uv/install.sh | sh{RESET}")
-        if "node" in errors or "npm" in errors:
+        if "node" in errors:
             print(f"    {RED}•{RESET} Node.js 18+ — {BOLD}https://nodejs.org{RESET}")
+        if "npm" in errors:
+            print(f"    {RED}•{RESET} npm not found (Node.js installed but npm missing from PATH) — {BOLD}https://nodejs.org{RESET}")
         print()
         print(f"  {YELLOW}Install the missing tools and run setup again.{RESET}")
         sys.exit(1)
@@ -333,7 +343,7 @@ def copy_env_example(config: dict):
         print(f"  {GREEN}✓{RESET} Created .env from .env.example")
     else:
         print(f"  {YELLOW}!{RESET} .env.example not found, creating empty .env")
-        dst.write_text("# EvoNexus Environment Variables\n# Fill in your API keys below\n\n")
+        dst.write_text("# EvoNexus Environment Variables\n# Fill in your API keys below\n\n", encoding="utf-8")
 
 
 def copy_routines_config(config: dict):
@@ -346,7 +356,7 @@ def copy_routines_config(config: dict):
     if src.exists():
         shutil.copy2(src, dst)
     else:
-        dst.write_text("# EvoNexus Routines — edit schedules here\n# See ROUTINES.md for documentation\n\ndaily: []\nweekly: []\nmonthly: []\n")
+        dst.write_text("# EvoNexus Routines — edit schedules here\n# See ROUTINES.md for documentation\n\ndaily: []\nweekly: []\nmonthly: []\n", encoding="utf-8")
     print(f"  {GREEN}✓{RESET} Created config/routines.yaml")
 
 
@@ -407,7 +417,7 @@ def main():
     # workspace.yaml
     config_dir = WORKSPACE / "config"
     config_dir.mkdir(exist_ok=True)
-    (config_dir / "workspace.yaml").write_text(generate_workspace_yaml(config))
+    (config_dir / "workspace.yaml").write_text(generate_workspace_yaml(config), encoding="utf-8")
     print(f"  {GREEN}✓{RESET} Generated config/workspace.yaml")
 
     # .env
@@ -418,7 +428,7 @@ def main():
 
     # CLAUDE.md
     claude_md = generate_claude_md(config)
-    (WORKSPACE / "CLAUDE.md").write_text(claude_md)
+    (WORKSPACE / "CLAUDE.md").write_text(claude_md, encoding="utf-8")
     print(f"  {GREEN}✓{RESET} Generated CLAUDE.md")
 
     # Folders

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ dependencies = [`
`15`	`15`	`"requests>=2.31",`
`16`	`16`	`"pyyaml>=6.0",`
`17`	`17`	`"flask-sock>=0.7",`
	`18`	`+ "pywinpty>=3.0.3; sys_platform == 'win32'",`
`18`	`19`	`]`
`19`	`20`
`20`	`21`	`[tool.uv]`