`gj  dZddlZddlZddlZddlmZmZddlmZm Z de e e e ffdZeZdee de e fdZdee fd Zd dd d ee d e deee de e fdZd dd d ee d e deee ddfdZy)aN Unified self-relaunch for Hermes CLI. Preserves critical flags (--tui, --dev, --profile, --model, etc.) across process replacement so that ``hermes sessions browse`` or post-setup relaunch doesn't silently drop the user's UI mode or other preferences. Also works when ``hermes`` is not on PATH (e.g. ``nix run`` or ``python -m``). N)OptionalSequence)PRE_ARGPARSE_INHERITED_FLAGSbuild_top_level_parserreturncdt\}}}g}t}||fD]y}|jD]h}|jst |dds|j dk7}|jD]-}||f} | |vs |j | |j| /j{|jt|S)u(Build the ``(option_string, takes_value)`` table of flags that must survive a self-relaunch, by introspecting the real parser used by ``hermes`` itself. A flag participates if its argparse Action carries ``inherit_on_relaunch = True`` — set by ``_parser._inherited_flag``. inherit_on_relaunchFr) rset_actionsoption_stringsgetattrnargsaddappendextendr) parser _subparsers chat_parsertableseenpaction takes_valueoptkeys F/root/.hermes/venv/lib/python3.12/site-packages/hermes_cli/relaunch.py_build_inherited_flag_tablers(>'?$FK$&E"%%Dk " &jj &F((6#8%@ ,,!+K,, &K(d?HHSMLL%  & & & LL-. Largvcg}d}|t|kr||}d|vrA|jddd}tD]\}}||k(s |j|n|dz }XtD]c\}}||k(s |j||rD|dzt|kr3||dzj ds|j||dz|dz }n|dz }|t|kr|S)zDPull out flags that should carry over into a self-relaunched hermes.r=-)lensplit_INHERITED_FLAGS_TABLEr startswith)rflagsiargrflag_rs r_extract_inherited_flagsr-6sE A c$i-1g #:))C#A&C1 a$;LL%  FA !7  D+d{ S!1q53t9#4T!a%[=S=STW=XLLa!e-FA   Q% c$i-& Lrc|tjd}tjdk(}dtdtfd}t j j|rOt j j|r0t j|t jr |r||s|S|jdsnt j j|rOt j j|}t j|t jr |r||s|Stjd}|r|Sy) u;Find the hermes entry point. Priority: 1. ``sys.argv[0]`` if it resolves to a real executable. 2. ``shutil.which("hermes")`` on PATH. 3. ``None`` → caller should fall back to ``python -m hermes_cli.main``. Windows note: ``os.access(path, os.X_OK)`` returns True for ``.py`` and ``.pyc`` files on Windows (the OS treats anything listed in PATHEXT as executable, and Python files are often registered there). But ``subprocess.run([script.py, ...])`` can't actually execute a .py directly — CreateProcessW needs a real .exe, not a script associated with the Python launcher. On Windows we therefore skip the argv[0] fast-path when it points at a .py file and fall through to either ``hermes.exe`` on PATH or the ``sys.executable -m hermes_cli.main`` fallback. rwin32rrc@|jjdS)N)z.pyz.pyc)lowerendswith)rs r_is_python_scriptz-resolve_hermes_bin.._is_python_scripteswwy!!/22rr#hermesN)sysrplatformstrboolospathisabsisfileaccessX_OKr'abspathshutilwhich)argv0 _is_windowsr3abs_pathpath_bins rresolve_hermes_binrFPs$ HHQKE,,')K3S3T3 ww}}Uu 5"))E277:S 1% 8L   C RWW^^E%:77??5) 99Xrww '$5h$?||H%H rTpreserve_inherited original_argv extra_argsrHrIct}|r|g}ntjddg}| t|nttjdd}|r|j t ||j ||S)aConstruct an argv list for replacing the current process with hermes. Args: extra_args: Arguments to append (e.g. ``["--resume", id]``). preserve_inherited: Whether to carry over UI / behaviour flags tagged with ``inherit_on_relaunch`` in the parser. original_argv: The original argv to scan for flags (defaults to ``sys.argv[1:]``). z-mzhermes_cli.mainNr")rFr5 executablelistrrr-)rJrHrIbin_pathrsrcs rbuild_relaunch_argvrP|sm"#Hz&78!.!:$} SXXab\@RC ,S12KK  Krc t|||}tjdk(r6ddl} |j |}tj |j ytj|d|y#t$rtj dYyt$rP}td|ddj|d tj tj d Yd}~yd}~wwxYw) uHReplace the current process with a fresh hermes invocation. On POSIX we use ``os.execvp`` which replaces the running process with the new one in place — same PID, no double-fork. That's what the relaunch contract wants: "run hermes again as if the user had typed the new argv". Windows has no native exec semantics — ``os.execvp`` on Windows *emulates* exec by spawning the child and exiting the parent, but only works when the target is a real Win32 executable. Our target is usually ``hermes.exe`` (a Python console-script shim that wraps ``python -m hermes_cli.main``) or a ``.cmd`` batch file, and both raise ``OSError(8, "Exec format error")`` on Windows' execvp. The Windows-correct pattern is: spawn the child with ``subprocess.run`` (which routes through ``cmd.exe`` via ``shell=False`` + PATHEXT resolution), wait for it to exit, then propagate its exit code via ``sys.exit``. That's functionally equivalent — the user sees "hermes exited, then new hermes started" — just with two PIDs in play instead of one. rGr/rNz Hermes relaunch failed: z Command:  z? Fix: open a new terminal so PATH picks up, then re-run hermes.)filer")rPr5r6 subprocessrunexit returncodeKeyboardInterruptOSErrorprintjoinstderrr9execvp)rJrHrInew_argvrUresultexcs rrelaunchrbs4#'9H ||w ^^H-F HHV&& ' (1+x(!  HHSM  ,SE2HHX./0QRZZ   HHQKK s0A22C*C*AC%%C*)__doc__r9r@r5typingrrhermes_cli._parserrrrMtupler7r8rr&r-rFrPrbrrrhs % T%T *:%;:568C=T#Y4)HSM)^ $-1  HSM*   #Y D $-1 2) 2)2)HSM* 2)  2)r