open-agents-ai 0.184.21 → 0.184.23

package/dist/index.js

@@ -46470,6 +46470,34 @@ function safeLog(text) {
     process.stdout.write(text + "\n");
   }
 }
+function findPidsByPattern(pattern) {
+  const isWin2 = process.platform === "win32";
+  try {
+    if (isWin2) {
+      const out = nodeExecSync(`wmic process where "CommandLine like '%${pattern.replace(/'/g, "")}%'" get ProcessId /format:csv`, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] });
+      return out.split("\n").map((l) => parseInt(l.split(",").pop() || "", 10)).filter((p) => p > 0 && !isNaN(p));
+    } else {
+      const out = nodeExecSync(`pgrep -f '${pattern}'`, { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] });
+      return out.trim().split("\n").map((s) => parseInt(s, 10)).filter((p) => p > 0 && !isNaN(p));
+    }
+  } catch {
+    return [];
+  }
+}
+function killPid(pid, signal = "SIGTERM") {
+  try {
+    if (process.platform === "win32") {
+      const flag = signal === "SIGKILL" ? "/F" : "";
+      nodeExecSync(`taskkill /PID ${pid} ${flag}`, { timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] });
+      return true;
+    } else {
+      process.kill(pid, signal);
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
 async function destroyOrphanProcesses(ctx, global) {
   const myPid = process.pid;
   const myPpid = process.ppid;
@@ -46512,28 +46540,58 @@ async function destroyOrphanProcesses(ctx, global) {
   ];
   const patternArg = patterns.join("|");
   let killed = 0;
+  const isWin2 = process.platform === "win32";
   try {
-    const psOutput = nodeExecSync(`ps -eo pid,ppid,rss,%cpu,lstart,args --no-headers 2>/dev/null | grep -E "${patternArg}" | grep -v grep`, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    let psOutput;
+    if (isWin2) {
+      psOutput = nodeExecSync(`wmic process get ProcessId,ParentProcessId,WorkingSetSize,CommandLine /format:csv`, { encoding: "utf-8", timeout: 1e4, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    } else {
+      psOutput = nodeExecSync(`ps -eo pid,ppid,rss,%cpu,lstart,args --no-headers 2>/dev/null | grep -E "${patternArg}" | grep -v grep`, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim();
+    }
     if (!psOutput)
       return 0;
     const lines = psOutput.split("\n").filter((l) => l.trim());
     const candidates = [];
-    for (const line of lines) {
-      const parts = line.trim().split(/\s+/);
-      const pid = parseInt(parts[0], 10);
-      const ppid = parseInt(parts[1], 10);
-      const rssKb = parseInt(parts[2], 10) || 0;
-      const cpuPct = parseFloat(parts[3]) || 0;
-      if (pid === myPid || pid === myPpid)
-        continue;
-      if (pid <= 10)
-        continue;
-      const cmd = parts.slice(8).join(" ");
-      candidates.push({ pid, ppid, rssMb: Math.round(rssKb / 1024), cpuPct, cmd });
+    if (isWin2) {
+      for (const line of lines) {
+        const cols = line.split(",");
+        if (cols.length < 5)
+          continue;
+        const cmdLine = cols[1] || "";
+        const ppid = parseInt(cols[2], 10) || 0;
+        const pid = parseInt(cols[3], 10) || 0;
+        const wsBytes = parseInt(cols[4], 10) || 0;
+        if (pid === myPid || pid === myPpid || pid <= 10)
+          continue;
+        const matchesPattern = patterns.some((p) => new RegExp(p.replace(/\\\\/g, "\\")).test(cmdLine));
+        if (!matchesPattern)
+          continue;
+        candidates.push({ pid, ppid, rssMb: Math.round(wsBytes / 1048576), cpuPct: 0, cmd: cmdLine.slice(0, 200) });
+      }
+    } else {
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parseInt(parts[0], 10);
+        const ppid = parseInt(parts[1], 10);
+        const rssKb = parseInt(parts[2], 10) || 0;
+        const cpuPct = parseFloat(parts[3]) || 0;
+        if (pid === myPid || pid === myPpid)
+          continue;
+        if (pid <= 10)
+          continue;
+        const cmd = parts.slice(8).join(" ");
+        candidates.push({ pid, ppid, rssMb: Math.round(rssKb / 1024), cpuPct, cmd });
+      }
     }
     if (!global) {
       const localCandidates = [];
       for (const c3 of candidates) {
+        if (isWin2) {
+          if (c3.cmd.includes(cwd4.replace(/\//g, "\\")) || /open-agents|nexus-daemon/.test(c3.cmd)) {
+            localCandidates.push(c3);
+          }
+          continue;
+        }
         try {
           const procCwd = nodeExecSync(`readlink /proc/${c3.pid}/cwd 2>/dev/null`, { encoding: "utf-8", timeout: 2e3 }).trim();
           if (procCwd.startsWith(cwd4)) {
@@ -46561,28 +46619,19 @@ async function destroyOrphanProcesses(ctx, global) {
 `);
     }
     for (const c3 of candidates) {
-      try {
+      if (!isWin2) {
         try {
           process.kill(-c3.pid, "SIGTERM");
         } catch {
         }
-        process.kill(c3.pid, "SIGTERM");
-        killed++;
-      } catch {
-        try {
-          process.kill(c3.pid, "SIGKILL");
-          killed++;
-        } catch {
-        }
       }
+      if (killPid(c3.pid, "SIGTERM"))
+        killed++;
     }
     if (killed > 0) {
       await new Promise((r) => setTimeout(r, 2e3));
       for (const c3 of candidates) {
-        try {
-          process.kill(c3.pid, "SIGKILL");
-        } catch {
-        }
+        killPid(c3.pid, "SIGKILL");
       }
     }
   } catch {
@@ -48011,22 +48060,14 @@ async function handleSlashCommand(input, ctx) {
             renderWarning(`Gateway stop: ${err instanceof Error ? err.message : String(err)}`);
           }
         }
-        try {
-          const { execSync: execSync34 } = __require("child_process");
-          const pids = execSync34("pgrep -f 'cloudflared tunnel --url http://127.0.0.1'", { encoding: "utf8", timeout: 3e3 }).trim().split("\n");
-          for (const pid of pids) {
-            const p = parseInt(pid, 10);
-            if (p > 0) {
-              try {
-                process.kill(p, "SIGTERM");
-              } catch {
-              }
-            }
-          }
-          if (pids.length > 0 && pids[0])
-            renderInfo(`Killed ${pids.length} orphaned cloudflared process(es).`);
-        } catch {
+        const orphanPids = findPidsByPattern("cloudflared tunnel --url http");
+        let orphansKilled = 0;
+        for (const pid of orphanPids) {
+          if (killPid(pid))
+            orphansKilled++;
         }
+        if (orphansKilled > 0)
+          renderInfo(`Killed ${orphansKilled} orphaned cloudflared process(es).`);
         renderInfo("Sponsorship removed.");
         return "handled";
       }
@@ -48067,20 +48108,15 @@ async function handleSlashCommand(input, ctx) {
           const existingGateway = ctx.getExposeGateway?.();
           const managedPid = existingGateway?._cloudflaredPid || null;
           if (!existingGateway?.isActive) {
-            try {
-              const { execSync: execSync34 } = __require("child_process");
-              const orphanPids = execSync34("pgrep -f 'cloudflared tunnel --url http://127.0.0.1'", { encoding: "utf8", timeout: 3e3 }).trim().split("\n").map((s) => parseInt(s, 10)).filter((p) => p > 0 && p !== managedPid);
-              for (const pid of orphanPids) {
-                try {
-                  process.kill(pid, "SIGTERM");
-                } catch {
-                }
-              }
-              if (orphanPids.length > 0) {
-                renderInfo(`Cleaned up ${orphanPids.length} orphaned tunnel(s) from previous session.`);
-                await new Promise((r) => setTimeout(r, 2e3));
-              }
-            } catch {
+            const staleOrphans = findPidsByPattern("cloudflared tunnel --url http").filter((p) => p !== managedPid);
+            let cleanedUp = 0;
+            for (const pid of staleOrphans) {
+              if (killPid(pid))
+                cleanedUp++;
+            }
+            if (cleanedUp > 0) {
+              renderInfo(`Cleaned up ${cleanedUp} orphaned tunnel(s) from previous session.`);
+              await new Promise((r) => setTimeout(r, 2e3));
             }
           }
           const tunnelAlreadyActive = existingGateway?.isActive && existingGateway?.tunnelUrl;
@@ -48109,15 +48145,29 @@ async function handleSlashCommand(input, ctx) {
             }
           }
           if (config.transport.libp2p && ctx.exposeStart) {
+            let daemonReady = false;
             try {
               const nexus = new NexusTool(projectDir);
-              renderInfo("Ensuring nexus daemon is connected...");
+              renderInfo("Starting nexus daemon...");
               await nexus.execute({ action: "connect" });
-              await new Promise((r) => setTimeout(r, 2e3));
+              for (let wait = 0; wait < 15; wait++) {
+                await new Promise((r) => setTimeout(r, 1e3));
+                try {
+                  const status = await nexus.execute({ action: "status" });
+                  if (typeof status === "string" && status.includes("connected")) {
+                    daemonReady = true;
+                    renderInfo("Nexus daemon ready.");
+                    break;
+                  }
+                } catch {
+                }
+              }
+              if (!daemonReady)
+                renderWarning("Nexus daemon did not become ready in 15s. P2P may fail.");
             } catch (err) {
-              renderWarning(`Nexus: ${err instanceof Error ? err.message : String(err)}`);
+              renderWarning(`Nexus connect: ${err instanceof Error ? err.message : String(err)}`);
             }
-            if (!p2pAlreadyActive) {
+            if (daemonReady && !p2pAlreadyActive) {
               try {
                 const url = await ctx.exposeStart("ollama", void 0, "libp2p");
                 if (url)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.184.21",
+  "version": "0.184.23",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) \u2014 interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",