forgexa-cli 1.3.2__tar.gz → 1.3.4__tar.gz

{forgexa_cli-1.3.2 → forgexa_cli-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.3.2
+Version: 1.3.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.3.2 → forgexa_cli-1.3.4}/forgexa_cli/__init__.py

@@ -1,2 +1,2 @@
 """forgexa-cli — Forgexa command-line client."""
-__version__ = "1.3.2"
+__version__ = "1.3.4"

{forgexa_cli-1.3.2 → forgexa_cli-1.3.4}/forgexa_cli/daemon.py

@@ -993,9 +993,19 @@ class WorkspaceManager:
                         os.write(fd, b"\n")
                     os.close(fd)
                     os.chmod(key_path, stat_mod.S_IRUSR)
+                    # On Windows, convert backslashes to forward slashes and quote
+                    # the path. Git invokes GIT_SSH_COMMAND via MSYS2 shell which
+                    # interprets backslashes as escape sequences, corrupting the
+                    # path (e.g. C:\Users → C:Users).
+                    key_path_safe = key_path.replace("\\", "/") if sys.platform == "win32" else key_path
                     env = {
                         **os.environ,
-                        "GIT_SSH_COMMAND": f"ssh -i {key_path} -o StrictHostKeyChecking=accept-new -o UserKnownHostsFile=/dev/null",
+                        "GIT_SSH_COMMAND": (
+                            f'ssh -i "{key_path_safe}"'
+                            f" -o StrictHostKeyChecking=accept-new"
+                            f" -o UserKnownHostsFile=/dev/null"
+                            f" -o IdentitiesOnly=yes"
+                        ),
                     }
                 except Exception:
                     try:
@@ -1031,10 +1041,12 @@ class WorkspaceManager:
             # Clean up temp SSH key file if created
             if env and "GIT_SSH_COMMAND" in env:
                 import re as _re
-                m = _re.search(r"-i\s+(\S+)", env["GIT_SSH_COMMAND"])
+                m = _re.search(r'-i\s+"?([^"\s]+)"?', env["GIT_SSH_COMMAND"])
                 if m:
+                    key_file = m.group(1)
+                    # Resolve forward-slash path back to native for unlink
                     try:
-                        os.unlink(m.group(1))
+                        os.unlink(key_file)
                     except OSError:
                         pass
         if proc.returncode != 0:
@@ -1422,10 +1434,19 @@ class ProcessManager:
             while True:
                 try:
                     line_bytes = await proc.stdout.readline()
-                except ValueError:
-                    # Line exceeded stream buffer limit – fall back to reading
-                    # remaining data in bulk to avoid losing output.
-                    remaining = await proc.stdout.read()
+                except (ValueError, asyncio.LimitOverrunError, Exception) as exc:
+                    # Line exceeded stream buffer limit (LimitOverrunError
+                    # converted to ValueError by readline(), but catch broadly
+                    # to handle edge cases in different Python versions).
+                    # Fall back to reading remaining data in bulk.
+                    logger.warning(
+                        "Stream read error for task %s (%s: %s), draining remaining output",
+                        task_id, type(exc).__name__, exc,
+                    )
+                    try:
+                        remaining = await proc.stdout.read()
+                    except Exception:
+                        remaining = b""
                     if remaining:
                         for chunk_line in remaining.decode(errors="replace").split("\n"):
                             if chunk_line:
@@ -1499,7 +1520,7 @@ class ProcessManager:
                 stdin=asyncio.subprocess.PIPE,
                 cwd=str(cwd),
                 env=env,
-                limit=10 * 1024 * 1024,  # 10MB line buffer for large JSON output
+                limit=100 * 1024 * 1024,  # 100MB line buffer for large JSON output from long sessions
             )
             self.active_processes[task_id] = proc
             stdout, stderr, returncode = await self._stream_process(
@@ -1533,6 +1554,17 @@ class ProcessManager:
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=f"Timed out after {timeout}s",
             )
+        except Exception as exc:
+            logger.exception("Claude stream error for task %s", task_id)
+            if task_id in self.active_processes:
+                try:
+                    self.active_processes[task_id].kill()
+                except Exception:
+                    pass
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=f"Stream processing error: {exc}",
+            )
         finally:
             self.active_processes.pop(task_id, None)
 
@@ -1600,7 +1632,7 @@ class ProcessManager:
                 stderr=asyncio.subprocess.PIPE,
                 stdin=asyncio.subprocess.PIPE if stdin_input else None,
                 cwd=str(cwd),
-                limit=10 * 1024 * 1024,  # 10MB line buffer for large agent output
+                limit=100 * 1024 * 1024,  # 100MB line buffer for large agent output
             )
             self.active_processes[task_id] = proc
             stdin_bytes = stdin_input.encode() if stdin_input else None
@@ -1622,6 +1654,17 @@ class ProcessManager:
                 status="failed", exit_code=-1, stdout="", stderr="",
                 error=f"Timed out after {timeout}s",
             )
+        except Exception as exc:
+            logger.exception("CLI stream error for task %s", task_id)
+            if task_id in self.active_processes:
+                try:
+                    self.active_processes[task_id].kill()
+                except Exception:
+                    pass
+            return TaskResult(
+                status="failed", exit_code=-1, stdout="", stderr="",
+                error=f"Stream processing error: {exc}",
+            )
         finally:
             self.active_processes.pop(task_id, None)
 
@@ -2499,40 +2542,118 @@ class RuntimeDaemon:
         CLI starts, etc.
         """
         lock_path = Path.home() / ".forgexa" / "daemon" / "daemon.lock"
+        pid_path = Path.home() / ".forgexa" / "daemon" / "daemon.pid"
         lock_path.parent.mkdir(parents=True, exist_ok=True)
 
         if sys.platform == "win32":
-            # Windows: use msvcrt file locking
+            # Windows: use msvcrt file locking.
+            #
+            # IMPORTANT: msvcrt.locking() creates mandatory byte-range locks
+            # that prevent OTHER processes from reading the locked bytes.
+            # Therefore we store the PID in a separate daemon.pid file that
+            # is never locked, so we can always read the old daemon's PID.
             import msvcrt
 
+            # ── Step 1: read old PID BEFORE touching the lock file ──
+            old_pid = None
+            try:
+                if pid_path.exists():
+                    old_pid = int(pid_path.read_text().strip())
+            except (ValueError, OSError):
+                pass
+
+            # ── Step 2: try to acquire the lock ──
             self._lock_file = open(lock_path, "w")
             try:
                 msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_NBLCK, 1)
             except (IOError, OSError):
-                # Lock held — try to kill old process via PID file
-                try:
-                    old_pid = int(lock_path.read_text().strip())
-                    logger.warning("Another daemon is running (PID %d). Terminating...", old_pid)
-                    import subprocess as _sp
-                    _sp.run(["taskkill", "/PID", str(old_pid), "/F"],
+                # Lock held by another daemon — kill it
+                import subprocess as _sp
+
+                if old_pid and old_pid != os.getpid():
+                    logger.warning("Another daemon (PID %d) holds the lock. Killing...", old_pid)
+                    _sp.run(["taskkill", "/PID", str(old_pid), "/F", "/T"],
                             capture_output=True)
-                    time.sleep(1)
-                except (ValueError, FileNotFoundError, PermissionError, OSError):
-                    pass
+                else:
+                    # No daemon.pid or PID matches us — find by process enumeration.
+                    # Uses PowerShell Get-CimInstance (reliable on all modern Windows).
+                    # wmic is deprecated since Windows 10 21H2 / Windows 11.
+                    logger.warning("No daemon PID file; killing daemon by process enumeration...")
+                    try:
+                        ps_script = (
+                            "Get-CimInstance Win32_Process | "
+                            "Where-Object { "
+                            "($_.CommandLine -like '*daemon.py*' -or $_.Name -eq 'forgexa-daemon.exe') "
+                            "-and $_.ProcessId -ne " + str(os.getpid()) + " } | "
+                            "Select-Object -ExpandProperty ProcessId"
+                        )
+                        result = _sp.run(
+                            ["powershell", "-NoProfile", "-NonInteractive", "-Command", ps_script],
+                            capture_output=True, text=True, timeout=15)
+                        for line in result.stdout.strip().splitlines():
+                            line = line.strip()
+                            if line.isdigit():
+                                pid = int(line)
+                                if pid != os.getpid():
+                                    logger.info("Killing orphan daemon process (PID %d)", pid)
+                                    _sp.run(["taskkill", "/PID", str(pid), "/F", "/T"],
+                                            capture_output=True)
+                    except Exception as e:
+                        logger.debug("Process enumeration fallback failed: %s", e)
+
+                # Wait for process to fully terminate and release file handles.
+                # Verify death before proceeding (Windows needs time to release handles).
+                time.sleep(2)
+                if old_pid and old_pid != os.getpid():
+                    for _ in range(6):  # Up to 3 more seconds
+                        try:
+                            result = _sp.run(
+                                ["tasklist", "/FI", f"PID eq {old_pid}", "/NH", "/FO", "CSV"],
+                                capture_output=True, text=True, timeout=5)
+                            if str(old_pid) not in result.stdout:
+                                break
+                        except Exception:
+                            break
+                        time.sleep(0.5)
 
-                # Retry
+                # Close our handle and remove stale lock file
                 self._lock_file.close()
-                self._lock_file = open(lock_path, "w")
                 try:
-                    msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_NBLCK, 1)
-                except (IOError, OSError):
+                    lock_path.unlink(missing_ok=True)
+                except OSError:
+                    pass
+
+                # Retry with backoff — up to 5 attempts (total ~15s)
+                acquired = False
+                for attempt in range(5):
+                    try:
+                        self._lock_file = open(lock_path, "w")
+                        msvcrt.locking(self._lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+                        acquired = True
+                        break
+                    except (IOError, OSError):
+                        self._lock_file.close()
+                        wait = (attempt + 1) * 1  # 1s, 2s, 3s, 4s, 5s
+                        logger.warning("Lock retry %d/5 failed, waiting %ds...", attempt + 1, wait)
+                        time.sleep(wait)
+
+                if not acquired:
                     logger.error("Cannot acquire daemon lock — another instance may still be running")
                     raise SystemExit(1)
 
+            # Write PID to lock file (for reference, though unreadable while locked)
             self._lock_file.seek(0)
             self._lock_file.truncate()
             self._lock_file.write(str(os.getpid()))
             self._lock_file.flush()
+
+            # Write PID to separate unlocked file — always readable by other
+            # processes (Rust manager, NSIS installer, next daemon instance).
+            try:
+                pid_path.write_text(str(os.getpid()))
+            except OSError as e:
+                logger.warning("Could not write daemon.pid: %s", e)
+
             logger.info("Acquired exclusive daemon lock (pid=%d)", os.getpid())
             return
 
@@ -2582,6 +2703,12 @@ class RuntimeDaemon:
         self._lock_file.flush()
         logger.info("Acquired exclusive daemon lock (pid=%d)", os.getpid())
 
+        # Write PID to separate file for consistency with Windows path
+        try:
+            pid_path.write_text(str(os.getpid()))
+        except OSError:
+            pass
+
         # Also clean up CLI daemon PID file if it points to a dead process
         cli_pid_file = Path.home() / ".forgexa-daemon.pid"
         if cli_pid_file.exists():
@@ -2623,20 +2750,37 @@ class RuntimeDaemon:
                        ", ".join(a.agent_id for a in self.agents))
 
         # 2. Register with all servers
-        for url in self.server_urls:
-            conn = ServerConnection(url, self.api_token, self.daemon_id, self.hardware_id)
-            try:
-                await conn.register(self.agents, self.max_concurrent)
-                conn.start_services(self.heartbeat_interval, self.poll_interval, self.agents)
-                await conn.start_heartbeat()
-                self.connections.append(conn)
-                logger.info("[%s] Connected and ready", conn.label)
-            except Exception as e:
-                logger.error("[%s] Failed to connect: %s — skipping this server", conn.label, e)
-                await conn.client.aclose()
+        # 2. Register with all servers (with retry on transient failures)
+        max_registration_attempts = 5
+        for attempt in range(max_registration_attempts):
+            for url in self.server_urls:
+                if any(c.server_url == url.rstrip("/") for c in self.connections):
+                    continue  # Already connected to this server
+                conn = ServerConnection(url, self.api_token, self.daemon_id, self.hardware_id)
+                try:
+                    await conn.register(self.agents, self.max_concurrent)
+                    conn.start_services(self.heartbeat_interval, self.poll_interval, self.agents)
+                    await conn.start_heartbeat()
+                    self.connections.append(conn)
+                    logger.info("[%s] Connected and ready", conn.label)
+                except Exception as e:
+                    logger.error("[%s] Failed to connect: %s — skipping this server", conn.label, e)
+                    await conn.client.aclose()
+
+            if self.connections:
+                break  # At least one server connected
+
+            if attempt < max_registration_attempts - 1:
+                wait = (attempt + 1) * 5  # 5s, 10s, 15s, 20s
+                logger.warning(
+                    "No servers reachable (attempt %d/%d). Retrying in %ds...",
+                    attempt + 1, max_registration_attempts, wait,
+                )
+                await asyncio.sleep(wait)
 
         if not self.connections:
-            logger.error("Failed to connect to any server. Exiting.")
+            logger.error("Failed to connect to any server after %d attempts. Exiting.",
+                         max_registration_attempts)
             raise SystemExit(1)
 
         logger.info("Daemon ready. Connected to %d server(s). Polling for tasks...",

{forgexa_cli-1.3.2 → forgexa_cli-1.3.4}/forgexa_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgexa-cli
-Version: 1.3.2
+Version: 1.3.4
 Summary: Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform
 Author-email: Jason Sun <dev.winds@gmail.com>
 License: MIT

{forgexa_cli-1.3.2 → forgexa_cli-1.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "forgexa-cli"
-version = "1.3.2"
+version = "1.3.4"
 description = "Forgexa CLI — command-line client and AI agent runtime for the Forgexa platform"
 requires-python = ">=3.9"
 license = { text = "MIT" }