code-puppy-core-plugins 0.0.50__tar.gz → 0.0.52__tar.gz

{code_puppy_core_plugins-0.0.50 → code_puppy_core_plugins-0.0.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy-core-plugins
-Version: 0.0.50
+Version: 0.0.52
 Summary: Official plugin bundle for Code Puppy
 Project-URL: Repository, https://github.com/mpfaffenberger/code_puppy_core_plugins
 Project-URL: Homepage, https://github.com/mpfaffenberger/code_puppy_core_plugins

{code_puppy_core_plugins-0.0.50 → code_puppy_core_plugins-0.0.52}/code_puppy_core_plugins/fork/register_callbacks.py

@@ -35,12 +35,15 @@ from __future__ import annotations
 import asyncio
 import inspect
 import itertools
+import logging
 import time
 from dataclasses import dataclass, field
 from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from code_puppy.callbacks import register_callback
 
+logger = logging.getLogger(__name__)
+
 _FORK = "fork"
 _FORKS = "forks"
 _PROMPT_PREVIEW_LEN = 60
@@ -282,6 +285,18 @@ async def _run_fork(
             )
 
 
+def _first_line(text: Any) -> str:
+    """First line of ``text``, or ``""`` when it has no non-blank content.
+
+    A whitespace-only error strips to no lines, so indexing ``[0]`` blindly
+    raised IndexError -- which the surrounding ``except`` then swallowed,
+    marking the fork ``failed`` with no banner at all.
+    """
+    stripped = str(text).strip()
+    lines = stripped.splitlines()
+    return lines[0] if lines else ""
+
+
 def _on_fork_done(fork_id: int, task: asyncio.Task) -> None:
     """Done-callback (runs in-loop): record outcome + emit a banner."""
     record = _forks.get(fork_id)
@@ -304,8 +319,8 @@ def _on_fork_done(fork_id: int, task: asyncio.Task) -> None:
         record.session_id = getattr(result, "session_id", None)
         if getattr(result, "error", None):
             record.status = "failed"
-            first_line = str(result.error).strip().splitlines()[0]
-            _emit_error(f"{tag} failed after {record.elapsed:.1f}s: {first_line}")
+            detail = _first_line(result.error) or "no error detail provided"
+            _emit_error(f"{tag} failed after {record.elapsed:.1f}s: {detail}")
             return
         record.status = "done"
         response = getattr(result, "response", None)
@@ -317,8 +332,25 @@ def _on_fork_done(fork_id: int, task: asyncio.Task) -> None:
             f"{tag} finished in {record.elapsed:.1f}s"
             + (f" — session '{record.session_id}'" if record.session_id else "")
         )
-    except Exception:  # pragma: no cover - banner must never break the loop
-        record.status = "failed"
+    except Exception as exc:
+        # Never let an unexpected error leave the fork silent: emit what we can,
+        # but keep the emit itself from breaking the loop. Only a fork still
+        # ``running`` may be promoted to ``failed`` -- every other status is a
+        # truthful terminal state (``done`` / ``cancelled``) that a rendering
+        # failure must not overwrite. Bare exceptions carry no message, so fall
+        # back to the exception type name rather than an empty banner.
+        detail = _first_line(exc) or type(exc).__name__
+        if record.status == "running":
+            record.status = "failed"
+            message = f"{tag} failed after {record.elapsed:.1f}s: {detail}"
+        else:
+            message = f"{tag} {record.status} but could not render its result: {detail}"
+        try:
+            _emit_error(message)
+        except Exception:  # pragma: no cover - banner must never break the loop
+            logger.warning(
+                "fork %s: could not emit completion banner", fork_id, exc_info=True
+            )
 
 
 def _start_fork(agent_name: str, prompt: str, model_name: str | None = None) -> None:

{code_puppy_core_plugins-0.0.50 → code_puppy_core_plugins-0.0.52}/code_puppy_core_plugins/herdr/register_callbacks.py

@@ -33,6 +33,12 @@ Callback -> effect:
 * ``awaiting_user_input`` ............................ blocked <-> not
 * ``post_autosave`` .................................. title refresh / wait
 
+Callbacks alone are not enough to guarantee the pane is released. They fire
+from a ``finally:`` in ``cli_runner``, which the interpreter only reaches on
+a graceful exit. ``_install_exit_guards`` adds an ``atexit`` hook and a
+SIGTERM/SIGHUP handler so a closed pane, a plain ``kill``, or a logout also
+release pane authority instead of stranding a dead agent in herdr's sidebar.
+
 Session identity is the durable autosave (name, path) resolved by
 ``sources.current_session_ref`` -- NOT the per-run ``group_id`` UUID, which
 changes every turn. Pane metadata (model / context / tokens), the
@@ -49,7 +55,10 @@ choice.
 
 from __future__ import annotations
 
+import atexit
 import logging
+import os
+import signal
 
 from code_puppy.callbacks import register_callback
 
@@ -58,6 +67,18 @@ from .reporter import HerdrReporter
 
 logger = logging.getLogger(__name__)
 
+#: Signals that terminate the process without unwinding the interpreter, so
+#: neither the ``finally:`` in cli_runner nor ``atexit`` would otherwise run.
+#: SIGKILL is deliberately absent -- it cannot be caught by design. SIGHUP is
+#: resolved defensively because it does not exist on Windows, where this
+#: module is still imported (client.py speaks a named pipe there) and a bare
+#: ``signal.SIGHUP`` would raise AttributeError and break the whole plugin.
+_TERMINATING_SIGNALS = tuple(
+    sig
+    for sig in (getattr(signal, name, None) for name in ("SIGTERM", "SIGHUP"))
+    if sig is not None
+)
+
 _client = HerdrClient()
 _reporter = HerdrReporter(_client)
 
@@ -126,6 +147,67 @@ def _on_shutdown(*_args, **_kw) -> None:
     _reporter.on_shutdown()
 
 
+def _install_exit_guards() -> None:
+    """Release the pane even when the interpreter never unwinds.
+
+    The ``shutdown`` / ``session_end`` callbacks fire from a ``finally:`` in
+    ``cli_runner``, which only runs on a graceful exit (``/exit``, EOF). A
+    terminal closing its pane, a plain ``kill``, a logout, or a service
+    restart all send SIGTERM/SIGHUP, whose *default* disposition terminates
+    the process immediately -- the ``finally:`` never executes, no
+    ``pane.release_agent`` is ever sent, and herdr keeps showing a dead
+    agent forever with no mechanism to reap it.
+
+    Two guards, because neither alone is sufficient:
+
+    * ``atexit`` -- covers ordinary interpreter teardown paths that bypass
+      the callback (an unhandled exception above the ``finally:``,
+      ``sys.exit()`` from a nested frame). It does **not** run on SIGTERM.
+    * a SIGTERM/SIGHUP handler -- covers the signal paths ``atexit`` misses.
+
+    The handler restores the previous disposition and re-raises so the
+    process still dies from the signal with correct ``128 + signum`` exit
+    status; it does not swallow the signal or alter shutdown semantics.
+    Any previously-installed handler is chained rather than clobbered.
+
+    SIGKILL cannot be caught, so a ``kill -9`` still strands the pane. That
+    residual case needs a herdr-side liveness check on the reporting
+    process and is out of scope here.
+    """
+    # release_and_close() is idempotent and bounded, so double-firing from
+    # both a signal and atexit is harmless.
+    atexit.register(_client.release_and_close)
+
+    previous_handlers = {}
+
+    def _release_and_reraise(signum: int, frame) -> None:
+        try:
+            _client.release_and_close()
+        except Exception:  # never let cleanup mask the shutdown itself
+            logger.debug("herdr: release on signal %s failed", signum, exc_info=True)
+
+        previous = previous_handlers.get(signum)
+        if callable(previous):
+            previous(signum, frame)
+            return
+
+        # Restore the default disposition and re-raise so the exit status
+        # remains 128 + signum rather than a synthetic 0.
+        signal.signal(signum, previous if previous is not None else signal.SIG_DFL)
+        os.kill(os.getpid(), signum)
+
+    for sig in _TERMINATING_SIGNALS:
+        try:
+            previous_handlers[sig] = signal.getsignal(sig)
+            signal.signal(sig, _release_and_reraise)
+        except (OSError, ValueError, AttributeError):
+            # signal.signal() only works on the main thread, and some signals
+            # are absent on some platforms (SIGHUP on Windows). Reporting must
+            # never break the agent, so degrade quietly.
+            previous_handlers.pop(sig, None)
+            logger.debug("herdr: could not install handler for %s", sig, exc_info=True)
+
+
 if _reporter.active:
     register_callback("startup", _on_startup)
     register_callback("user_prompt_submit", _on_user_prompt)
@@ -140,6 +222,7 @@ if _reporter.active:
     register_callback("awaiting_user_input", _on_awaiting_user_input)
     register_callback("session_end", _on_shutdown)
     register_callback("shutdown", _on_shutdown)
+    _install_exit_guards()
     logger.debug("herdr plugin active for pane %s", _client._pane_id)
 else:
     logger.debug("herdr plugin inactive (not running inside a herdr pane)")

{code_puppy_core_plugins-0.0.50 → code_puppy_core_plugins-0.0.52}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy-core-plugins"
-version = "0.0.50"
+version = "0.0.52"
 description = "Official plugin bundle for Code Puppy"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"