fix: detect npm.cmd on Windows in setup prerequisite check (#2)

mareanalitica · claude · web-flow · commit 2224bb3d3c53 · 2026-04-10T10:19:27.000-03:00
* fix: detect npm.cmd on Windows in setup prerequisite check On Windows/Git Bash, npm may only be available as npm.cmd and not  directly as npm. Falls back to npm.cmd when the plain npm command fails. Also separates the error messages for node and npm so the user knows exactly which tool is missing instead of both being reported as "Node.js 18+".

* fix: add explicit utf-8 encoding to write_text calls in setup.py
Prevents UnicodeEncodeError on systems where the default locale is not UTF-8 (e.g., Windows with cp1252). Also syncs package-lock.json with updated dependency tree.

* feat: add Windows ConPTY support to terminal backend

Replace Unix-only PTY (pty/fcntl/termios) with a platform-aware
implementation that uses pywinpty on Windows and the existing PTY
stack on Unix. All session lifecycle operations (spawn, kill,
resize, WebSocket I/O) now branch on sys.platform.

Adds pywinpty&gt;=3.0.3 as a conditional Windows dependency.

Co-Authored-By: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;

---------

Co-authored-by: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
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]`