sjrZdZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZddlmZddlmZddlmZmZmZmZddlmZddlmZdd lmZejeZ e!ej"d Z#e#re $ej%e j&Z'd Z(Gd d e)Z*GddZ+dee,gdfdzddfdZ-dee,gdfdzfdZ.de/de,ddfdZ0defdZ1dej2de,ddfdZ3 d1de4e,de,dzdej2fdZ5dede/fdZ6dede/ddfd Z7d!e,de8e9e:fdzfd"Z;Gd#d$eZ<Gd%d&Z=d'e,de,fd(Z>d)Z?ej@d*ZA d2d,e,d-ee,de,fd.ZBGd/d0e ZCdS)3aCBase class for all Hermes execution environment backends. Unified spawn-per-call model: every command spawns a fresh ``bash -c`` process. A session snapshot (env vars, functions, aliases) is captured once at init and re-sourced before each command. CWD persists via in-band stdout markers (remote) or a temp file (local). N)ABCabstractmethod)deque)Path)IOCallableIterableProtocol)get_hermes_home)windows_hide_flags)is_interruptedHERMES_DEBUG_INTERRUPTlc2eZdZdZdddedeffdZxZS)EnvironmentConnectionErroruInfrastructure/connection-class failure of a terminal backend. Raised when the backend itself is unreachable (SSH host down, Docker daemon not running, remote file sync failing on a dead link) — never for a command that merely exited nonzero. Subclassing RuntimeError keeps every existing ``except RuntimeError`` catcher working. ``terminal_tool`` turns this into a structured ``status: "degraded"`` tool result (config gate ``terminal.degraded_mode: warn|fail``) so the model gets an actionable reason + retry hint instead of a traceback. The failed backend is never cached, so a later call retries from scratch and simply works once the backend is reachable again. ) retry_hintreasonrcjt|||_|pd|_dS)NuThis is an infrastructure failure, not a command failure. Verify the backend is reachable (network, service running, credentials), then retry the same command — recovery is automatic once the backend is back.)super__init__rr)selfrr __class__s ;/home/agent/.hermes/hermes-agent/tools/environments/base.pyrz#EnvironmentConnectionError.__init__Fs:     $  2 )__name__ __module__ __qualname____doc__strr __classcell__)rs@rrr7sd  :<   s 3          rrceZdZdZdZddeddfdZded dfd Zdd Z e d efd Z e d efdZ ded dfdZ ddded efdZdS)_BoundedOutputCollectoru_Retain a bounded 40/60 head-tail window of streamed text. When ``spill_path`` is set, the collector also tees the FULL stream to that file once eviction begins (up to ``_SPILL_CAP_CHARS``), so a truncated foreground result is recoverable without re-running the command. Memory stays bounded either way — the spill is disk-only. i@KLN max_chars spill_pathz Path | Nonecptdt||_t|jdz|_|j|jz |_g|_t |_d|_d|_ d|_ tj |_ ||_d|_d|_d|_dS)N皙?rF)maxintr# _head_limit _tail_limit_headr_tail _head_chars _tail_chars _total_chars threadingLock_lock _spill_path _spill_fh _spill_chars _spill_capped)rr#r$s rrz _BoundedOutputCollector.__init__^sQI//t~344>D,<< " !& ^%% %)-"rtextreturnc|j|jrdS |jddlm}m}||jjd||jdd|_d|jd|j z}|j |t||_ |j |j z }|dkst||krR|j |dtd||j d d|_n|j ||xj t|z c_ dS#t$r d|_YdSwxYw) zATee ``text`` to the spill file (opened lazily on first overflow).Nr)ensure_spill_diropen_exclusiveT)privatereplace)r=errorsrz+ ... [spill capped at 5,000,000 chars] ... )r4r7r5tools.spill_safetyr;r<parentjoinr,r-writelenr6_SPILL_CAP_CHARSr(OSError)rr8r;r<backlogbudgets r _maybe_spillz$_BoundedOutputCollector._maybe_spillms   #t'9 # F &~%OOOOOOOO ! !1!8$GGGG!/$d9""" ''$*-- 0C0CC$$W---$'LL!*T->>F{{c$ii&00$$T/3q&>>/%:;;;$$%TUUU%)""$$T***   T *     & & &!%D     &sEE&&E;:E; str | Nonec|j5|j ddddS |jn#t$rYnwxYwd|_t |jcdddS#1swxYwYdS)z8Close the spill file and return its path if it was used.N)r3r5closerFrr4rs r close_spillz#_BoundedOutputCollector.close_spills Z ) )~% ) ) ) ) ) ) ) ) $$&&&&    !DNt'(( ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )s1 A09A0 AA0AA00A47A4cb|j5|j|jzcdddS#1swxYwYdSN)r3r.r/rMs rbuffered_charsz&_BoundedOutputCollector.buffered_charss| Z 7 7#d&66 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7s $((cR|j5|jcdddS#1swxYwYdSrP)r3r0rMs r total_charsz#_BoundedOutputCollector.total_charsst Z % %$ % % % % % % % % % % % % % % % % % %s   c|sdS|j5t|}|j/|j|j|z|jkr|||xj|z c_d}|j|jkrSt|j|jz |}|r4|j |d||xj|z c_|}||z }|dks |j dkr ddddS||j kr[|j |j ||j d|j |_ ddddS||d}|j ||xjt|z c_|j|j kr|j|j z }|j d}t||kr7|j |xjt|zc_n"||d|j d<|xj|zc_|j|j kddddS#1swxYwYdS)Nr)r3rDr4r5r0r#rIr.r*minr,appendr+r-clearr/popleft) rr8text_lenstarttake remainingchunkexcessfirsts rrVz_BoundedOutputCollector.appends  F Z' /' /4yyH+*$x/$.@@!!$'''    )  E$"2224+d.>>II!J%%d5D5k222$$,$$ E 5(IA~~!1Q!6!6+' /' /' /' /' /' /' /' /,D,,,   """ !!$(8'8':':";<<<#'#3 5' /' /' /' /' /' /' /' /8LE J  e $ $ $   E *  "T%555)D,<< 1 u::''J&&((($$E 2$$$$)&''NDJqM$$.$$"T%555?' /' /' /' /' /' /' /' /' /' /' /' /' /' /' /' /' /' /s CI+AIC)II I rsuffixrac B|j5t||jkr||j dcdddSd|j}d|j}|jt|z }|j|kr||z|zcdddSd}tdD]n}td|t|z }t|dz}||z } td|j|z | z } d| dd|jdd } | |krn| }otd|t|z }t|dz}||z } | r || dnd} |d||d|z| z|zcdddS#1swxYwYdS) zARender within ``max_chars``, preserving a required status suffix.Nrrr'z ... [OUTPUT TRUNCATED - ,z chars omitted out of z total] ... ) r3rDr#rBr,r-r0ranger(r)) rraheadtail availablenotice_content_budget head_chars tail_charsomittedupdated rendered_tails rrenderz_BoundedOutputCollector.renders Z S S6{{dn,,t~o//0 S S S S S S S S774:&&D774:&&DV4I I--d{V+ S S S S S S S SF1XX ! !!$Q CKK(?!@!@ #!566 +j8 a!2Z!?*!LMMC7MCC"/BCCCf$$E  IF $;<Register a callback that _wait_for_process fires periodically.N)_activity_callback_localcallback)rts rset_activity_callbackrxs(*%%%rc.ttddS)ujReturn the thread-local activity callback (see ``set_activity_callback``). Public accessor for callers outside this module that need to capture the calling thread's callback before handing work to another thread (the callback is thread-local, so a freshly spawned thread cannot read it back) — e.g. the manual cron-run heartbeat (#76502). rwN)getattrrvrsrrget_activity_callbackr{s +Z > >>rstatelabelctj}|dd}||dz |krdS||d< t}|r+t ||dz }||d|ddSdS#t $rYdSwxYw)a_Fire the activity callback at most once every ``state['interval']`` seconds. *state* must contain ``last_touch`` (monotonic timestamp) and ``start`` (monotonic timestamp of the operation start). An optional ``interval`` key overrides the default 10 s cadence. Swallows all exceptions so callers don't need their own try/except. intervalg$@ last_touchNrZz (z s elapsed))time monotonicgetr{r) Exception)r|r}nowrrtelapseds rtouch_activity_if_duers .  CyyT**H U<  8++E, " $ $  0#g.//G B%..7... / / / / / 0 0      s9A>> B  B ctjd}|rt|}ntdz }|dd|S)zReturn the host-side root for all sandbox storage (Docker workspaces, Singularity overlays/SIF cache, etc.). Configurable via TERMINAL_SANDBOX_DIR. Defaults to {HERMES_HOME}/sandboxes/. TERMINAL_SANDBOX_DIR sandboxesTparentsexist_ok)osgetenvrr mkdir)customps rget_sandbox_dirrsT Y- . .F , LL    +GGD4G((( Hrprocdatacg_fd}tj|d}|_|dS)uWrite *data* to proc.stdin on a daemon thread to avoid pipe-buffer deadlocks. On Windows, text-mode stdin (``text=True`` / ``encoding="utf-8"``) translates ``\n`` → ``\r\n`` as the data flows through the pipe — which corrupts every write_file / patch call because the bytes that land on disk include injected carriage returns. The file IS created, but every subsequent byte-count / content compare against the caller's ``\n``-only string fails. Workaround: write through ``proc.stdin.buffer`` (the underlying byte buffer), encoding to UTF-8 ourselves. That bypasses Python's newline translation entirely on every platform. No behaviour change on POSIX — the byte sequence is identical to what text-mode would produce there. Encoding uses ``errors="surrogateescape"`` — the exact inverse of the surrogateescape decode, so original bytes are restored. For surrogate-free strings it is byte-identical to strict UTF-8. Surrogates outside the round-trip range U+DC80–U+DCFF raise and are recorded on ``proc._hermes_stdin_errors`` while stdin is still closed in ``finally`` so the child sees EOF instead of hanging; ``_wait_for_process`` reads the recorded error and surfaces it as ``stdin_error`` on the result. cj$tddStjdj} t t rddn}||}|t|kr#td|dt|dn>#ttf$rYn+t$r}|Yd}~nd}~wwxYw | dS#t$rYdSwxYw# | w#t$rYwwxYwxYw)Nzprocess stdin unavailablebufferutf-8surrogateescapezshort stdin write: z of z bytes) stdinrV RuntimeErrorrz isinstancerencoderCrDBrokenPipeErrorrFrrL)targetrawwrittenexcrr?rs r_writez_pipe_stdin.._writeKs :  MM,'BCC D D D FXtz:: =Gc=R=R\$++g'8999X\Cll3''G#c((""##V#V#Vc#hh#V#V#VWWW# )    D    MM#                      ss A8CD(C=D( C=C83D(8C==D(D D%$D%(E*D?>E? E  E E  ETrdaemonN)_hermes_stdin_errorsr1Thread_hermes_stdin_threadrZ)rrrthreadr?s`` @r _pipe_stdinr.sg4#%F &D8 VD 9 9 9F &D LLNNNNNrcmd stdin_datac |dttj|ftjtj| tjn tjdddd|}|t|||S)aSpawn a subprocess with standard stdout/stderr/stdin setup. If *stdin_data* is provided, writes it asynchronously via :func:`_pipe_stdin`. Backends with special Popen needs (e.g. local's ``preexec_fn``) can bypass this and call :func:`_pipe_stdin` directly. creationflagsNTrr>)stdoutstderrrr8encodingr?) setdefaultr subprocessPopenPIPESTDOUTDEVNULLr)rrkwargsrs r _popen_bashrls o'9';';<<<     !+!7jooZ=O GI       DD*%%% Krpathc|r9 tj|dS#t$rYnwxYwiS)z:Load a JSON file as a dict, returning ``{}`` on any error.rr)existsjsonloads read_textr)rs r_load_json_storersZ {{}} :dnngn>>?? ?    D  Is'> A  A c|jdd|tj|dddS)z.Write *data* as pretty-printed JSON to *path*.Tr)indentrrN)rAr write_textrdumps)rrs r_save_json_storersHKdT222OODJtA...OAAAAAr host_pathc t|}|j|jfS#t$rYdSwxYw)zIReturn ``(mtime, size)`` for cache comparison, or ``None`` if unreadable.N)rstatst_mtimest_sizerF)rsts r_file_mtime_keyrsO )__ ! ! # # RZ(( tts .1 ??ceZdZdZdedzfdZd dZd dedzdefdZe de e dzfdZ e dedzfd Z dS) ProcessHandlezDuck type that every backend's _run_bash() must return. subprocess.Popen satisfies this natively. SDK backends (Modal, Daytona) return _ThreadedProcessHandle which adapts their blocking calls. r9NcdSrPrsrMs rpollzProcessHandle.pollrcdSrPrsrMs rkillzProcessHandle.killrrtimeoutcdSrPrsrrs rwaitzProcessHandle.waitrrcdSrPrsrMs rrzProcessHandle.stdout(+rcdSrPrsrMs r returncodezProcessHandle.returncoderrr9NrP)rrrrr)rrfloatrrrrrrrrsrrrrs &cDj%%%%< (output_str, exit_code)`` in a background thread and exposes a ProcessHandle-compatible interface. An optional ``cancel_fn`` is invoked on ``kill()`` for backend-specific cancellation (e.g. Modal sandbox.terminate, Daytona sandbox.stop). Nexec_fn cancel_fnc8|_tj_d_d_t j\}}t j|ddd_ |_ fd}tj |d}| dS)Nrrr>)rr?c \}}|_ tjj|ddn#t $rYnwxYwn%#t $r}|_d_Yd}~nd}~wwxYw tjjn#t $rYnwxYwj dS# tjjn#t $rYnwxYwj wxYw)Nrr>r?r&) _returncoderrC _write_fdrrFr_errorrL_doneset)output exit_coderrrs r_workerz0_ThreadedProcessHandle.__init__.._workersO !$+GII! #, HT^V]]79]-U-UVVVVD % % %! #$       %HT^,,,,D      HT^,,,,D     sA/AA AAAAC A;#A61C6A;;C?B B&%B&D C D  C-*D ,C--D Tr) _cancel_fnr1Eventrrrrpipefdopen_stdoutrrrZ)rrrread_fdwrite_fdrts`` rrz_ThreadedProcessHandle.__init__s $_&& '+(, GIIy# RRR ! ! ! ! ! ! !&  GD 9 9 9  rc|jSrP)rrMs rrz_ThreadedProcessHandle.stdouts |rr9c|jSrP)rrMs rrz!_ThreadedProcessHandle.returncodes rcF|jr|jndSrP)ris_setrrMs rrz_ThreadedProcessHandle.polls##':#4#4#6#6@tD@rcd|jr( |dS#t$rYdSwxYwdSrP)rrrMs rrz_ThreadedProcessHandle.killsS ?  !!!!!      s  --rcF|j||jS)Nr)rrrrs rrz_ThreadedProcessHandle.waits! (((rrP)rrrrrtuplerr)rrrrrrrrrrsrrrrs04##"eCHo-.#BH%,####JX C$J   X AcDjAAAA  EDL C      rr session_idcd|dS)N __HERMES_CWD___rs)rs r _cwd_markerrs ): ) ) ))rz`^declare -x (HERMES_SESSION_|HERMES_UI_SESSION_ID|HERMES_CRON_AUTO_DELIVER_|HERMES_CRON_SESSION)z^[A-Za-z_][A-Za-z0-9_]*$rstmp_pathexcluded_namescd|D}ddt|D}|rd|}d|d|S)uReturn a shell snippet that dumps ``export -p`` to *tmp_path* minus the per-session bridged vars (see ``_SNAPSHOT_EXCLUDED_ENV_REGEX``) and any additional names supplied by the caller. Unset the bridged vars in a subshell *before* ``export -p``. A line-based ``grep -vE`` filter is unsafe: bash 3.2 prints a value containing a newline as a multi-line ``declare -x NAME="…`` block, so only the opener matches the regex and continuation lines (e.g. ``curl … | bash #`` smuggled into a Matrix room/display name via ``HERMES_SESSION_CHAT_NAME``) land in the snapshot and execute on the next ``source`` (issue #71296). Unsetting first means ``export -p`` never emits those vars — including any continuation lines. ``|| true`` keeps the success contract for callers that chain on it. The dump MUST be wrapped in a brace group with the redirection applied to the group. *tmp_path* is typically a shell-variable expansion (a mktemp-allocated per-writer temp name); a redirection attached to a pipeline segment would expand it inside that segment's subshell, potentially inconsistently with the parent that expands the follow-up ``mv``. The brace-group redirect is expanded in the current shell, keeping both expansions consistent. c@h|]}t|t||Srs)rr.0names r z6_export_dump_excluding_session_vars..6s@ dC %) r c3>K|]}tj|VdSrPshlexquoter s r z6_export_dump_excluding_session_vars..:s,LL5;t,,LLLLLLrzh{ ( unset ${!HERMES_SESSION_*} ${!HERMES_CRON_AUTO_DELIVER_*} AI_AGENT HERMES_AGENT HERMES_UI_SESSION_IDz( 2>/dev/null; export -p; ) || true; } > )rBsorted)rr safe_names extra_unsets r#_export_dump_excluding_session_varsrs:'J((LL 9K9KLLLLLK('+''   +    rc2eZdZUdZdZeed<dZeed<dZ e ed<defd Z d6d ed ed e fdZ ddd ddede d eded zdef dZedZdeefdZdeedffdZdZed edefdZdedefdZded edefdZedededefdZ d7dd d!ed ed"e de fd#Zed$d%d&ed'ed zde fd(Zd!efd)Zd*e fd+Zd*e fd,Z d8d-Z! d9d d d/dd0ded ed ed zded zd1e d"e de fd2Z"d3Z#d4Z$dedeeed zffd5Z%d S):BaseEnvironmentaCommon interface and unified execution flow for all Hermes backends. Subclasses implement ``_run_bash()`` and ``cleanup()``. The base class provides ``execute()`` with session snapshot sourcing, CWD tracking, interrupt handling, and timeout enforcement. r _stdin_mode_snapshot_timeoutF_profile_scoped_passthroughr9cdS)a,Return the backend temp directory used for session artifacts. Most sandboxed backends use ``/tmp`` inside the target environment. LocalEnvironment overrides this on platforms like Termux where ``/tmp`` may be missing and ``TMPDIR`` is the portable writable location. z/tmprsrMs r get_temp_dirzBaseEnvironment.get_temp_dirfs vrNcwdrenvc||_||_|pi|_tjjdd|_|dpd}|d|jd|_ |d|jd|_ t|j|_ d|_ t|_d|_dS)N /z /hermes-snap-z.shz /hermes-cwd-z.txtF)r rr!uuiduuid4hex _session_idrrstrip_snapshot_path _cwd_filer_snapshot_readyr_snapshot_passthrough_names_prefer_nonlogin)rr rr!temp_dirs rrzBaseEnvironment.__init__os 9":<<+CRC0$$&&--c229c!)MM8HMMM$HH$2BHHH&t'788$58UU(!&rxloginrr cmd_stringr2rcJtt|jd)zSpawn a bash process to run *cmd_string*. Returns a ProcessHandle (subprocess.Popen or _ThreadedProcessHandle). Must be overridden by every backend. z must implement _run_bash())NotImplementedErrortyper)rr3r2rrs r _run_bashzBaseEnvironment._run_bashs$"T$ZZ%8"U"U"UVVVrcdS)z.s_88!$,,82D1M1Md1S1S8888888rz4Could not refresh profile-scoped snapshot exclusionsT)exc_info) ragent.secret_scoper=tools.env_passthroughr>r;r-updaterloggerdebugrr)rr=r>namess r$_snapshot_excluded_passthrough_namesz4BaseEnvironment._snapshot_excluded_passthrough_namess/ 2  > > > > > >""$$ EEEEEE((**FFHH07788 %888     LLF        VD<==>>>sAA''&BBc||j}||j}||jdz}d}|}d|dt ||d|d|d|d|d |d |d |d |d |d|jd|jd} ||d|j}| ||j}t| dpddkr%td| dd|_ ||td|j|jdS#t$$r?} d|_ t'| } d} |ddt)d|j} | | t)d|j} t| dpddk} | s+| dp| p| } n#t$$r}| d|} Yd}~nd}~wwxYw| |_| r"td|j| n'td|j| Yd} ~ dSYd} ~ dSd} ~ wwxYw) zCapture login shell environment into a snapshot file. Called once after backend construction. On success, sets ``_snapshot_ready = True`` so subsequent commands source the snapshot instead of running with ``bash -l``. .tmp.XXXXXXXXXX"$__hermes_snap_tmp"z%umask 077 __hermes_snap_tmp=$(mktemp z ) || exit 1 z __hermes_fns=$(declare -F | awk '{print $3}' | grep -vE '^_[^_]') || true [ -n "$__hermes_fns" ] && declare -f $__hermes_fns >> z! 2>/dev/null || true alias -p >> z# echo 'shopt -s expand_aliases' >> z echo 'set +e' >> z echo 'set +u' >> z mv -f rz || rm -f z builtin cd -- z 2>/dev/null || true printf '\n%sz\n' "$(pwd -P)" T)r2rrrrz)snapshot bootstrap failed with exit code z-Session snapshot created (session=%s, cwd=%s)Ftruerz; non-login probe: Nu_init_session failed (session=%s): %s — login bash unusable; falling back to non-login bash -cuLinit_session failed (session=%s): %s — falling back to bash -l per command)_quote_cwd_for_cdr _quote_shell_pathr*rIrrr7r_wait_for_processr)rrr, _update_cwdrFinfor(rrrUstripr.warning)r _quoted_cwd _quoted_snap_snap_tmp_template _snap_tmpsnapshot_excluded bootstraprresultrdetailprefer_nonloginprobe probe_result probe_excs r init_sessionzBaseEnvironment.init_sessions ,,TX66 --d.ABB *"33D4GJ[4[\\*  EEGG U*< U U29>OPP U U"# U U$%% U U&2;' U U(!*) U U*!*+ U U01 U U0".1 U U0:C1 U U2)3 U U4*5 U U4/3.>5 U U U :- >>)4AW>XXD++D$:P+QQF6::l++0q11Q66"Z <@X@XZZ$(D   V $ $ $ KK?          #(D XXF#O CvUCDLbDcDcdd#55eSTMcEdEd5ee "%l&6&6|&D&D&I"J"Ja"O&V*..x88BFIIKKUvF C C C"BByBB C%4D ! M$ :$ ' sE+CE55 J?J:B*IJ: IIJ:IAJ::J?c|dkr|S|dkrdS|drdtj|ddStj|S)z7Quote a ``cd`` target while preserving ``~`` expansion.~z~/z$HOMEz$HOME/rN) startswithrr)r s rrPz!BaseEnvironment._quote_cwd_for_cd=sd #::J $;;7 >>$   32EKABB0022 2{3rrc*tj|S)zQuote *path* for interpolation into a bash script. LocalEnvironment overrides this to rewrite native/mixed Windows paths to ``/c/...`` before quoting. Remote backends leave paths as-is (they already speak POSIX). r)rrs rrQz!BaseEnvironment._quote_shell_pathHs{4   rcommandc |dd}||j}||jdz}d}g}|}g} |D]_} d| } | d} | d} | | | | f|| d| d || d| d `|jr|d |d | D]C\} } } |d | d| d| d| d |d| d| D|d||}|d|d|d|d|d|d|jr3|d|dt||d|d|d|d |d|jd |jd!|d"d# |S)$zwBuild the full bash script that sources snapshot, cd's, runs command, re-dumps env vars, and emits CWD markers.'z'\''rKrL_HERMES_RUNTIME_PASSTHROUGH__PRESENT_VALUEz=${z+x}z-}zsource z >/dev/null 2>&1 || truezif [ "$z" = x ]; then export z="$z"; else unset z; fizunset rzPexport AI_AGENT="${AI_AGENT:-hermes-agent}" HERMES_AGENT="${HERMES_AGENT:-true}"zbuiltin cd -- z || exit 126zeval 'z__hermes_ec=$?z umask 077z__hermes_snap_tmp=$(mktemp z) && { z && mv -f z; } 2>/dev/null || rm -f z 2>/dev/null || truez printf '\nrMz\n' "$(pwd -P)"zexit $__hermes_ec ) r>rQr*rIrVr,rPrrrB)rrhr escapedrXrYrZpartspassthrough_names saved_namesr markerpresentvalue quoted_cwds r _wrap_commandzBaseEnvironment._wrap_commandQsH//#w//--d.ABB "33D4GJ[4[\\*  EEGG35 % 2 2D:D::F)))G%%%E   gu5 6 6 6 LLG33333 4 4 4 LLE00t000 1 1 1 1    LL@,@@@   %0 5 5 D'5 LL)'))))))")))    LL3'33E33 4 4 4 4   3   ++C00  >j>>>???  (g((())) %&&&  [!!!    LLH.@HH9)EVWWHH%HH(4HH)2HHH     R$* R Rd.> R R R     ()))yyrcbdtjjdd}|d|d|d|S)z;Append stdin_data as a shell heredoc to the command string. HERMES_STDIN_Nr#z << 'z' rn)r%r&r')rhr delimiters r_embed_stdin_heredocz$BaseEnvironment._embed_stdin_heredocsGt8d1|||t j|dz j-t3d2d}||!d3!#}|"|j-}t3d4d}|r&t]|d}||d5<|d6|d7z|d8<|S)9uPoll-based wait with interrupt checking and stdout draining. Shared across all backends — not overridden. ``bounded_capture=True`` (foreground terminal-tool path only) retains at most ``tool_output.max_bytes`` of output in a head/tail window while draining, so a verbose subprocess cannot OOM the process (#64435). The default (False) preserves full-fidelity capture for internal consumers — file-operation ``cat`` reads feeding the patch engine, code-execution RPC reads, log reads — where truncation would corrupt data. Fires the ``activity_callback`` (if set on this instance) every 10s while the process is running so the gateway's inactivity timeout doesn't kill long-running commands. Also wraps the poll loop in a ``try/finally`` that guarantees we call ``self._kill_process(proc)`` if we exit via ``KeyboardInterrupt`` or ``SystemExit``. Without this, the local backend (which spawns subprocesses with ``os.setsid`` into their own process group) leaves an orphan with ``PPID=1`` when python is shut down mid-tool — the ``sleep 300``-survives-30-min bug Physikal and I both hit. r) get_max_bytesiPNcachezterminal-outputzout--ixz.logi: z out-*.log)r$rr>rc  |D]e}|t|tr)|Ct |fn#t $rYnwxYw dd}|r|dSdS#t $rYdSwxYw# dd}|r|ww#t $rYwwxYwxYw)NrTfinal)rbytesrVdecoderr)streampiecergdecoderrs r_drain_iterablez:BaseEnvironment._wait_for_process.._drain_iterable%sZ #22E} !%//2 gnnU&;&;<<<< c%jj1111 2    ">>#T>::D, d+++++,, DD ">>#T>::D, d++++, Ds`A(A,+C, A96C8A99C=.B// B=<B=D.C20D2 C?<D>C??DcP j}|dSt|dd} t|r |nd}n#t$rd}YnwxYwt |t r|dkr |dSt jdkr t j|d}|sn) |An#ttf$rYnwxYw dd}|r |nU#t$rYnIwxYw# dd}|r |ww#t$rYwwxYwxYwdSd} tj |gggd\}}}n#ttf$rYnwxYw|r\ t j|d}n#ttf$rYnSwxYw|snL |d}n  |d z }|d krn dd}|r |dSdS#t$rYdSwxYw# dd}|r |ww#t$rYwwxYwxYw) NfilenorntTrrg?r&)rrzcallablerrr)rr readrVr ValueErrorrFselectr) rrfdr]rgidle_after_exitreadyrjrrrrs r_drainz1BaseEnvironment._wait_for_process.._drain?s[F~VXt44F !)&!1!1;VVXXXt    b#&& "q&&'''w$= "D 1 1$"! gnnU&;&;<<< =""G,D&~~c~>>0"MM$///$ &~~c~>>0"MM$////0$O "&,mRD"b#&F&F q!!&0""$&GB$5$5EE *G4"""!E"$"! gnnU&;&;<<<*+0(1,*a//!)"2">>#T>::D, d+++++,, DD ">>#T>::D, d++++, Ds; A  A AC D CD CD !.D DD E"".EE" EE"EE"*I#,F I# FI#FI##F98I#9G  I# G  AI# .I I I #J%%.JJ% J"J%!J""J%Tr)rrZpidFzg[interrupt-debug] _wait_for_process ENTER tid=%s pid=%s timeout=%ss activity_cb=%s initial_interrupt=%srMISSINGg{Gzt?r&ut[interrupt-debug] _wait_for_process INTERRUPT DETECTED tid=%s pid=%s iter=%d elapsed=%.1fs — killing process grouprZrrz [Command interrupted]r`zM[interrupt-debug] _wait_for_process TIMEOUT tid=%s pid=%s iter=%d timeout=%ssz [Command timed out after zs]|zterminal command runningg>@zo[interrupt-debug] _wait_for_process HEARTBEAT tid=%s pid=%s iter=%d elapsed=%.0fs interrupt=%s activity_cb=%s%sz (LOST during run)rg?g?u[interrupt-debug] _wait_for_process EXCEPTION_EXIT tid=%s pid=%s iter=%d elapsed=%.1fs — killing subprocess group before re-raisezd[interrupt-debug] _wait_for_process EXIT (natural) tid=%s pid=%s iter=%d elapsed=%.1fs returncode=%srr stdin_errorz [stdin write failed: ]r)/tools.tool_output_limitsr~r_UNBOUNDED_CAPTURE_CHARSr r)rrgetpididis_dirglobrrunlinkrFr"codecsgetincrementaldecoderr1rrZrcurrent_threadidentrzr{_DEBUG_INTERRUPTrFrTr r _kill_processrB_finalize_wait_resultrqrSlstriprsleeprUKeyboardInterrupt SystemExitrrLrr) rrrr|r~ capture_limitr$ spill_dircutoffoldr drain_threaddeadline_now_activity_state_tid_pid _iter_count_last_heartbeat_last_interrupt_state _cb_was_none _poll_sleep timeout_msg _cb_now_none stdin_threadrenderedr] stdin_errorserrrrrs ` @@@rrRz!BaseEnvironment._wait_for_processs4  5 'BBBBBB -   ' ' ' &  ' 5M  " "+--7:KK &)jDIKK0@0@)j)j29;;)j)jQSTXQYQY\bQb)j)j)j)jj ##%%!!Y[[94F(~~k::!!!"xxzz2V;; # &!!! D! " " "!  "(:NNN48&.w77yIII      4F F F F F F F F P!'vdCCC >##g-~  '))/tUD))  %,..$6   KKBdG)8y     W K))++%q !## ' \ $ T^5E5EX_H`5` &&t,,, %%a%00055 -F GG >##h..' @ $ W &&t,,, %%a%000"K"K"K"KK55!-22 [ 99@@BBB#]]+]>> &o7QRRR $ 0(8(8?(Jd(R(R#8#:#:d#BLKK8dK((?7+CC&((%1@y0<Y\Y,,WY   '+n&6&6O#/L ;'''$$"%kC&7"="=KA))++%B":.      g$ N$$w'??   ""4(((!!!!,,,,     ) 2 !$$$  K          D    KKDdK  ?7#;;    t%;TBB  #   a  ( ( (==??++FHdoNNt%;TBB  Kl1o&&C$'F= !'*JC*J*J*JJF8  s ((B$D1D D DDDD D.-D.R0;C R0C)R00AT?+T-,T?- T:7T?9T::T?U33 V?V collectorr"rrcZ||d}|}|r|j|d<||d<|S)zHAssemble a wait result, attaching spill metadata when overflow occurred.)rroutput_total_charsfull_output_path)rNrS)rrrr]spills rrz%BaseEnvironment._finalize_wait_result sH%J??%%''  /+4+@F' ().F% & rcl |dS#tttf$rYdSwxYw)zDTerminate a process. Subclasses may override for process-group kill.N)rProcessLookupErrorPermissionErrorrF)rrs rrzBaseEnvironment._kill_process+sA  IIKKKKK"OW=    DD s 33r]c0||dS)zDExtract CWD from command output. Override for local file-based read.N)_extract_cwd_from_output)rr]s rrSzBaseEnvironment._update_cwd6s %%f-----rcL|dd}|j}||}|dkrdStd|dz }||||}|dks||krdS||t |z|}|r ||_d|d<|d d|}|dkr|}|d |t |z} | dkr| d znt |} |d||| dz|d<dS) aParse the __HERMES_CWD_{session}__ marker from stdout output. Updates self.cwd and strips the marker from result["output"]. Used by remote backends (Docker, SSH, Modal, Daytona, Singularity). Sets ``result["cwd_observed"]`` when the marker yielded a directory for THIS command. The wrapper prints the marker after the command returns, so a killed / timed-out command never emits one and ``self.cwd`` keeps whatever the previous command left there. That environment is shared by every session, so callers must not attribute an unobserved cwd to the session that ran this command (see terminal_tool's session-cwd record). rrNrrT cwd_observedrnr&)rrrfindr(rDrUr find) rr]rrslast search_startr_cwd_path line_startline_ends rrz(BaseEnvironment._extract_cwd_from_output:sDHb))!||F## 2:: F1dTk**  V\488 B;;%4-- F%#f++-45;;==  *DH%)F> " \\$511   J;;tTCKK%788#+r>>8a<Hook called before each command execution. Remote backends (SSH, Modal, Daytona) override this to trigger their FileSyncManager. Bind-mount backends (Docker, Singularity) and Local don't need file sync — the host filesystem is directly visible inside the container/process. NrsrMs r_before_executezBaseEnvironment._before_executehs  rrT)rrrewrite_compound_backgroundr|rc|||\}}|rddlm} | |}|p|j} |p|j} ||||z} n||} n|} | r#|jdkr||| }d} ||| } |j o|j }| | || | }| || |}| ||S)uExecute a command, return {"output": str, "returncode": int}. ``bounded_capture=True`` caps stdout/stderr retention at ``tool_output.max_bytes`` WHILE the stream is drained (head/tail window) instead of holding the full output in memory (#64435). It must only be set by callers whose output is destined for the model/tool payload (the foreground terminal tool). Internal full-fidelity consumers — file operations ``cat`` reads that feed the patch engine, code-execution RPC reads, log reads — MUST leave it False: truncating those corrupts data, not just display. r)_rewrite_compound_backgroundNheredocr1)rr|)r_prepare_commandtools.terminal_toolrrr rr{rwr,r.r7rRrS)rrhr rrrr| exec_command sudo_stdinreffective_timeout effective_cwdeffective_stdinwrappedr2rr]s rexecutezBaseEnvironment.executevs]* #'#8#8#A#A j ' F H H H H H H77 EEL#3t|tx   !j&<(:5OO  #(OO(O  #t/9<<44\?SSL"O$$\=AA((F1F-F~~ 5*;  '' +_(       rc.|dS)z.Alias for cleanup (compat with older callers).N)r9rMs rstopzBaseEnvironment.stops rcR |dS#t$rYdSwxYwrP)r9rrMs r__del__zBaseEnvironment.__del__s:  LLNNNNN    DD s  &&c$ddlm}||S)z6Transform sudo commands if SUDO_PASSWORD is available.r)_transform_sudo_command)rr)rrhrs rrz BaseEnvironment._prepare_commands%??????&&w///rrP)r0r)r)&rrrrrr__annotations__rr)rboolrdictrrr7rr9r r;rrIrc staticmethodrPrQrwr{rRrrrSrrrrrrrsrrrrSs K s ).---c&&C&#&D&&&&2!% W W W W W  W $J W  W W W W  ^ hsm?eCHo????rs   ########333333333333,,,,,,<<<<<<******  8 $ $ 4  ":;;<<"  OOGL!!!+9?,, %        4\S\S\S\S\S\S\S\S~+hud{3d:+t++++ ?xt 4t;????        4       (;j&;c;d;;;;~.2 c #d .4DB4BtBBBBB suUCZ'84'?,,,,,H,,,$B B B B B B B B T*C*C****.g RZ ;<< %'222SM2 2222ts 0s 0s 0s 0s 0cs 0s 0s 0s 0s 0r