Windows port: platform-agnostic IPC, fcntl shim, POSIX signal guards, Task Scheduler daemon

bench/consolidation_rss_peak.py

@@ -4,7 +4,6 @@
 import gc
 import json
 import os
-import resource
 import shutil
 import sys
 import tempfile
@@ -38,6 +37,14 @@ def _cur_rss_bytes() -> int:
 
 
 def _ru_maxrss_bytes() -> int:
+    if sys.platform == "win32":
+        try:
+            import psutil
+            mi = psutil.Process().memory_info()
+            return int(getattr(mi, "peak_wset", mi.rss))
+        except Exception:
+            return 0
+    import resource
     r = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
     if sys.platform == "darwin":
         return int(r)

bench/embed_warm_cost.py

@@ -58,23 +58,42 @@
 """
 
 _PAYLOAD_RSS = r"""
-import sys, resource
+import sys
 sys.path.insert(0, {src_path!r})
+import platform as _plat
+_system = _plat.system()
+if _system == "Windows":
+    import psutil as _psutil
+    def _peak_raw():
+        mi = _psutil.Process().memory_info()
+        return int(getattr(mi, "peak_wset", mi.rss))
+    def _to_mb(raw):
+        return raw / 1048576
+    _unit_is_bytes = True
+else:
+    import resource as _resource
+    def _peak_raw():
+        return _resource.getrusage(_resource.RUSAGE_SELF).ru_maxrss
+    if _system == "Darwin":
+        def _to_mb(raw):
+            return raw / 1048576
+        _unit_is_bytes = True
+    else:
+        def _to_mb(raw):
+            return raw / 1024
+        _unit_is_bytes = False
 from iai_mcp.embed import Embedder
 e = Embedder()
-rss_post_construct_raw = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
+rss_post_construct_raw = _peak_raw()
 text = {text!r}
 _ = e.embed(text)
-rss_post_encode_raw = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
-import platform as _plat
-is_mac = (_plat.system() == "Darwin")
-def to_mb(raw):
-    return raw / 1048576 if is_mac else raw / 1024
-print(f"rss_post_construct_mb={{to_mb(rss_post_construct_raw):.1f}}")
-print(f"rss_post_encode_mb={{to_mb(rss_post_encode_raw):.1f}}")
+rss_post_encode_raw = _peak_raw()
+print(f"rss_post_construct_mb={{_to_mb(rss_post_construct_raw):.1f}}")
+print(f"rss_post_encode_mb={{_to_mb(rss_post_encode_raw):.1f}}")
 print(f"rss_post_construct_raw={{rss_post_construct_raw}}")
 print(f"rss_post_encode_raw={{rss_post_encode_raw}}")
-print(f"unit_is_bytes={{is_mac}}")
+print(f"unit_is_bytes={{_unit_is_bytes}}")
+print(f"rss_platform={{_system}}")
 """
 
 
@@ -210,17 +229,25 @@ def measure_rss(src_path: str, text: str) -> dict:
     rss_post_construct_mb = float(kv["rss_post_construct_mb"])
     rss_post_encode_mb = float(kv["rss_post_encode_mb"])
     unit_is_bytes = kv["unit_is_bytes"] == "True"
+    rss_platform = kv.get("rss_platform", "")
+    if rss_platform == "Windows":
+        unit_label = "bytes (Windows peak_wset)"
+    elif rss_platform == "Darwin" or (unit_is_bytes and not rss_platform):
+        unit_label = "bytes (macOS)"
+    else:
+        unit_label = "KB (Linux)"
     print(
         f"  RSS post-construct={rss_post_construct_mb:.1f}MB  "
         f"post-first-encode={rss_post_encode_mb:.1f}MB  "
-        f"unit={'bytes (macOS)' if unit_is_bytes else 'KB (Linux)'}"
+        f"unit={unit_label}"
     )
     return {
         "rss_post_construct_mb": rss_post_construct_mb,
         "rss_post_encode_mb": rss_post_encode_mb,
         "rss_post_construct_raw": int(kv["rss_post_construct_raw"]),
         "rss_post_encode_raw": int(kv["rss_post_encode_raw"]),
         "unit_is_bytes_macos": unit_is_bytes,
+        "rss_platform": rss_platform,
     }
 
 

bench/memory_footprint.py

@@ -4,7 +4,6 @@
 import gc
 import json
 import os
-import resource
 import sys
 import tempfile
 import time
@@ -42,6 +41,11 @@ def _threshold_mb_for_n(n: int) -> float:
 
 
 def _rss_mb() -> float:
+    if sys.platform == "win32":
+        import psutil
+        mi = psutil.Process().memory_info()
+        return float(getattr(mi, "peak_wset", mi.rss)) / 1024.0 / 1024.0
+    import resource
     r = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
     if sys.platform == "darwin":
         return float(r) / 1024.0 / 1024.0

bench/memorygraph_memory.py

@@ -2,7 +2,6 @@
 
 import argparse
 import gc
-import resource
 import sys
 from pathlib import Path
 from uuid import uuid4
@@ -14,6 +13,11 @@
 
 
 def rss_mb() -> float:
+    if sys.platform == "win32":
+        import psutil
+        mi = psutil.Process().memory_info()
+        return float(getattr(mi, "peak_wset", mi.rss)) / (1024 * 1024)
+    import resource
     ru = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss
     if sys.platform == "darwin":
         return ru / (1024 * 1024)

mcp-wrapper/src/bridge.ts

@@ -1,13 +1,13 @@
 
 import * as crypto from "node:crypto";
 import * as net from "node:net";
-import * as os from "node:os";
-import * as path from "node:path";
+import {
+  type ConnectTarget,
+  createDaemonConnection,
+  daemonUnreachableHint,
+  getDaemonConnectTarget,
+} from "./ipc.js";
 
-function getDaemonSocketPath(): string {
-  return process.env.IAI_DAEMON_SOCKET_PATH
-    ?? path.join(os.homedir(), ".iai-mcp", ".daemon.sock");
-}
 const SOCKET_CONNECT_TIMEOUT_MS = 5000;
 const ERR_DAEMON_UNREACHABLE = -32002;
 
@@ -69,29 +69,30 @@ export class PythonCoreBridge {
   private async _doStart(): Promise<void> {
     this.reconnectAttempted = false;
 
+    const target = getDaemonConnectTarget();
+    if (target === null) {
+      throw new DaemonUnreachableError(daemonUnreachableHint());
+    }
+
     let sock: net.Socket;
     try {
       sock = await this.connectWithTimeout(
-        getDaemonSocketPath(),
+        target,
         SOCKET_CONNECT_TIMEOUT_MS,
       );
     } catch (e) {
-      throw new DaemonUnreachableError(
-        "iai-mcp daemon not running. "
-        + "Run: launchctl load -w ~/Library/LaunchAgents/com.iai-mcp.daemon.plist "
-        + "or run scripts/install.sh"
-      );
+      throw new DaemonUnreachableError(daemonUnreachableHint());
     }
     this.sock = sock;
     this.attachSocketHandlers();
   }
 
   private connectWithTimeout(
-    socketPath: string,
+    target: ConnectTarget,
     timeoutMs: number,
   ): Promise<net.Socket> {
     return new Promise((resolve, reject) => {
-      const sock = net.createConnection(socketPath);
+      const sock = createDaemonConnection(target);
       // Keep a pending/abandoned connect attempt from pinning the event loop
       // (e.g. an in-flight reconnect after socket death). A live connected
       // socket re-refs below so real RPC still holds the process open.
@@ -193,8 +194,12 @@ export class PythonCoreBridge {
         if (testDelayMs > 0) {
           await new Promise<void>((r) => setTimeout(r, testDelayMs));
         }
+        const target = getDaemonConnectTarget();
+        if (target === null) {
+          return;
+        }
         this.sock = await this.connectWithTimeout(
-          getDaemonSocketPath(),
+          target,
           SOCKET_CONNECT_TIMEOUT_MS,
         );
         this.attachSocketHandlers();
@@ -254,13 +259,6 @@ export class PythonCoreBridge {
 }
 
 
-export function sessionOpenSocketPath(): string {
-  const env = process.env.IAI_DAEMON_SOCKET_PATH;
-  if (env) return env;
-  return path.join(os.homedir(), ".iai-mcp", ".daemon.sock");
-}
-
-
 export function newSessionId(): string {
   return crypto.randomUUID();
 }
@@ -275,8 +273,12 @@ export function emitSessionOpen(sessionId: string): Promise<void> {
       resolve();
     };
     try {
-      const socketPath = sessionOpenSocketPath();
-      const sock = net.createConnection(socketPath, () => {
+      const target = getDaemonConnectTarget();
+      if (target === null) {
+        finish();
+        return;
+      }
+      const sock = createDaemonConnection(target, () => {
         const msg =
           JSON.stringify({
             type: "session_open",

mcp-wrapper/src/ipc.ts

@@ -0,0 +1,97 @@
+
+/**
+ * Platform-agnostic IPC transport, mirroring the Python `iai_mcp._ipc` module.
+ *
+ *   POSIX:   Unix-domain socket  ->  ~/.iai-mcp/.daemon.sock
+ *   Windows: TCP loopback         ->  127.0.0.1:<port>, port read from
+ *                                     ~/.iai-mcp/.daemon.port
+ *
+ * The base dir is ~/.iai-mcp (os.homedir()) to match `_ipc._BASE_DIR`, which
+ * uses Path.home() regardless of IAI_MCP_STORE.
+ */
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export const IS_WINDOWS = process.platform === "win32";
+
+export type ConnectTarget = string | { host: string; port: number };
+
+function daemonBaseDir(): string {
+  return path.join(os.homedir(), ".iai-mcp");
+}
+
+export function daemonSocketPath(): string {
+  return path.join(daemonBaseDir(), ".daemon.sock");
+}
+
+export function daemonPortFile(): string {
+  return path.join(daemonBaseDir(), ".daemon.port");
+}
+
+export function readDaemonPort(): number | null {
+  try {
+    const txt = fs.readFileSync(daemonPortFile(), "utf-8").trim();
+    const port = Number.parseInt(txt, 10);
+    return Number.isFinite(port) && port > 0 ? port : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the daemon IPC endpoint.
+ *   POSIX   -> Unix-domain socket path (string)
+ *   Windows -> { host: "127.0.0.1", port } from the port file
+ * Returns null when the endpoint cannot be determined (on Windows: port file
+ * absent => daemon not running). IAI_DAEMON_SOCKET_PATH overrides on POSIX.
+ */
+export function getDaemonConnectTarget(): ConnectTarget | null {
+  const env = process.env.IAI_DAEMON_SOCKET_PATH;
+  if (env) return env;
+  if (IS_WINDOWS) {
+    const port = readDaemonPort();
+    return port === null ? null : { host: "127.0.0.1", port };
+  }
+  return daemonSocketPath();
+}
+
+export function daemonUnreachableHint(): string {
+  if (IS_WINDOWS) {
+    return (
+      "iai-mcp daemon not running. "
+      + 'Start it with: schtasks /Run /TN "iai-mcp-daemon" '
+      + "(or: iai-mcp daemon install)."
+    );
+  }
+  if (process.platform === "darwin") {
+    return (
+      "iai-mcp daemon not running. "
+      + "Run: launchctl load -w ~/Library/LaunchAgents/com.iai-mcp.daemon.plist "
+      + "or run scripts/install.sh"
+    );
+  }
+  return (
+    "iai-mcp daemon not running. "
+    + "Run: systemctl --user start iai-mcp-daemon or run scripts/install.sh"
+  );
+}
+
+/**
+ * Open a net.Socket to the daemon for either transport. Accepts the union
+ * target returned by getDaemonConnectTarget so callers stay platform-agnostic.
+ */
+export function createDaemonConnection(
+  target: ConnectTarget,
+  connectListener?: () => void,
+): net.Socket {
+  if (typeof target === "string") {
+    return connectListener
+      ? net.createConnection(target, connectListener)
+      : net.createConnection(target);
+  }
+  return connectListener
+    ? net.createConnection(target.port, target.host, connectListener)
+    : net.createConnection(target.port, target.host);
+}