mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-08 13:12:08 +00:00
a88e0fd2ab
_sync_back_once defers a SIGINT that lands mid-sync, then re-delivers it once the sync completes so the user's Ctrl+C isn't lost. It did so with os.kill(os.getpid(), signal.SIGINT). That is not graceful on Windows: os.kill only treats CTRL_C_EVENT(0)/CTRL_BREAK_EVENT(1) as console events; any other value (SIGINT == 2) routes to TerminateProcess(sig), so a Ctrl+C during a remote-backend (ssh/daytona/modal) sync-back hard-kills the whole CLI session (exit code 2) on Windows instead of raising KeyboardInterrupt. Use signal.raise_signal(signal.SIGINT) (3.8+), which invokes the restored handler through C raise() on every platform. Verified on Windows: raise_signal runs the handler (graceful) while os.kill(getpid, SIGINT) TerminateProcess-es the process. Adds a cross-platform regression test that runs on Windows too (it stubs the locked sync body, so unlike test_file_sync_back.py it needs no fcntl).
56 lines
2 KiB
Python
56 lines
2 KiB
Python
"""Cross-platform regression for the deferred-SIGINT re-delivery in sync-back.
|
|
|
|
``_sync_back_once`` defers a Ctrl+C that lands mid-sync, then re-delivers it once
|
|
the sync completes. It must do so via ``signal.raise_signal`` — which invokes the
|
|
handler through C ``raise()`` on every platform — and NOT via
|
|
``os.kill(os.getpid(), signal.SIGINT)``: on Windows the latter routes SIGINT (2)
|
|
to ``TerminateProcess`` and hard-kills the whole CLI instead of raising
|
|
``KeyboardInterrupt``.
|
|
|
|
Unlike ``test_file_sync_back.py`` this module does not depend on ``fcntl`` (the
|
|
locked sync body is stubbed), so it runs on Windows too — the platform the bug
|
|
actually manifests on.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import os
|
|
import signal
|
|
|
|
from tools.environments.file_sync import FileSyncManager
|
|
|
|
|
|
def _make_manager() -> FileSyncManager:
|
|
return FileSyncManager(
|
|
get_files_fn=lambda: {},
|
|
upload_fn=lambda *a, **k: None,
|
|
delete_fn=lambda *a, **k: None,
|
|
)
|
|
|
|
|
|
def test_deferred_sigint_redelivered_via_raise_signal(tmp_path, monkeypatch):
|
|
mgr = _make_manager()
|
|
|
|
# Simulate a Ctrl+C arriving during the sync body: invoke the deferring
|
|
# handler that _sync_back_once installed, so `deferred_sigint` is populated.
|
|
def fake_locked(lock_path):
|
|
signal.getsignal(signal.SIGINT)(signal.SIGINT, None)
|
|
|
|
monkeypatch.setattr(mgr, "_sync_back_locked", fake_locked)
|
|
|
|
raised: list[int] = []
|
|
killed: list[tuple[int, int]] = []
|
|
monkeypatch.setattr(
|
|
"tools.environments.file_sync.signal.raise_signal", raised.append
|
|
)
|
|
monkeypatch.setattr(
|
|
"tools.environments.file_sync.os.kill",
|
|
lambda pid, sig: killed.append((pid, sig)),
|
|
)
|
|
|
|
mgr._sync_back_once(tmp_path / "sync.lock")
|
|
|
|
# The deferred Ctrl+C is re-delivered cross-platform via raise_signal,
|
|
assert raised == [signal.SIGINT]
|
|
# and never through os.kill(getpid, SIGINT) (which hard-kills on Windows).
|
|
assert (os.getpid(), signal.SIGINT) not in killed
|