feat: add --no-gui flag and fix win32 console crash

cli.py

@@ -1491,7 +1491,11 @@ def _replay_output_history() -> None:
         _OUTPUT_HISTORY_REPLAYING = False
 
 
-def _cprint(text: str):
+def is_interactive():
+    import sys
+    return sys.stdout.isatty()
+
+def _cprint(text: str, force_plain: bool = False):
     """Print ANSI-colored text through prompt_toolkit's native renderer.
 
     Raw ANSI escapes written via print() are swallowed by patch_stdout's
@@ -1507,12 +1511,22 @@ def _cprint(text: str):
     ``loop.call_soon_threadsafe``, which pauses the input area, prints
     the line above it, and redraws the prompt cleanly.
     """
+    if force_plain or not is_interactive():
+        print(text)
+        return
+
     _record_output_history(text)
 
+    def _safe_print():
+        try:
+            _pt_print(_PT_ANSI(text))
+        except Exception:
+            print(text)
+
     try:
         from prompt_toolkit.application import get_app_or_none, run_in_terminal
     except Exception:
-        _pt_print(_PT_ANSI(text))
+        _safe_print()
         return
 
     app = None
@@ -1525,15 +1539,15 @@ def _cprint(text: str):
     # direct prompt_toolkit print is safe and matches existing behavior
     # (spinner frames, streamed tokens, tool activity prefixes, …).
     if app is None or not getattr(app, "_is_running", False):
-        _pt_print(_PT_ANSI(text))
+        _safe_print()
         return
 
     try:
         loop = app.loop  # type: ignore[attr-defined]
     except Exception:
         loop = None
     if loop is None:
-        _pt_print(_PT_ANSI(text))
+        _safe_print()
         return
 
     import asyncio as _asyncio
@@ -1549,29 +1563,23 @@ def _cprint(text: str):
         current_loop = None
     # Same thread as the app's loop → safe to print directly.
     if current_loop is loop and loop.is_running():
-        _pt_print(_PT_ANSI(text))
+        _safe_print()
         return
 
     # Cross-thread emission: ask the app's event loop to schedule a
-    # ``run_in_terminal`` that wraps ``_pt_print``.  This hides the
+    # ``run_in_terminal`` that wraps ``_safe_print``.  This hides the
     # prompt, prints, and redraws.  Fire-and-forget — if scheduling
     # fails we fall back to a direct print so the line isn't lost.
     def _schedule():
         try:
-            run_in_terminal(lambda: _pt_print(_PT_ANSI(text)))
+            run_in_terminal(lambda: _safe_print())
         except Exception:
-            try:
-                _pt_print(_PT_ANSI(text))
-            except Exception:
-                pass
+            _safe_print()
 
     try:
         loop.call_soon_threadsafe(_schedule)
     except Exception:
-        try:
-            _pt_print(_PT_ANSI(text))
-        except Exception:
-            pass
+        _safe_print()
 
 
 # ---------------------------------------------------------------------------
@@ -2297,6 +2305,7 @@ def __init__(
         checkpoints: bool = False,
         pass_session_id: bool = False,
         ignore_rules: bool = False,
+        headless: bool = False,
     ):
         """
         Initialize the Hermes CLI.
@@ -2316,6 +2325,7 @@ def __init__(
         # Initialize Rich console
         self.console = Console()
         self.config = CLI_CONFIG
+        self.headless = headless
         self.compact = compact if compact is not None else CLI_CONFIG["display"].get("compact", False)
         # tool_progress: "off", "new", "all", "verbose" (from config.yaml display section)
         # YAML 1.1 parses bare `off` as boolean False — normalise to string.
@@ -4259,6 +4269,8 @@ def _show_security_advisories(self):
 
     def show_banner(self):
         """Display the welcome banner in Claude Code style."""
+        if getattr(self, "headless", False):
+            return
         self.console.clear()
         ctx_len = None
         if hasattr(self, 'agent') and self.agent and hasattr(self.agent, 'context_compressor'):
@@ -11196,8 +11208,88 @@ def _build_tui_layout_children(
             ] if item is not None
         ]
 
+    def _run_headless_loop(self, stdin=None):
+        """Process newline-delimited prompts from stdin for --no-gui mode."""
+        input_stream = sys.stdin if stdin is None else stdin
+        for line in input_stream:
+            line = line.rstrip("\r\n")
+            if not line:
+                continue
+            self._agent_running = True
+            try:
+                self.chat(line)
+            except (KeyboardInterrupt, BrokenPipeError, EOFError):
+                raise
+            except Exception:
+                self._agent_running = False
+                raise
+            else:
+                self._agent_running = False
+
+    def _finalize_run(self):
+        """Release CLI resources and close the active session."""
+        self._should_exit = True
+        # Interrupt the agent immediately so its daemon thread stops making
+        # API calls and exits promptly (agent_thread is daemon, so the
+        # process will exit once the main thread finishes, but interrupting
+        # avoids wasted API calls and lets run_conversation clean up).
+        if self.agent and getattr(self, '_agent_running', False):
+            try:
+                self.agent.interrupt()
+            except Exception:
+                pass
+        # Shut down voice recorder (release persistent audio stream)
+        if hasattr(self, '_voice_recorder') and self._voice_recorder:
+            try:
+                self._voice_recorder.shutdown()
+            except Exception:
+                pass
+            self._voice_recorder = None
+        # Clean up old temp voice recordings
+        try:
+            from tools.voice_mode import cleanup_temp_recordings
+            cleanup_temp_recordings()
+        except Exception:
+            pass
+        # Unregister callbacks to avoid dangling references
+        set_sudo_password_callback(None)
+        set_approval_callback(None)
+        set_secret_capture_callback(None)
+        # Close session in SQLite
+        if hasattr(self, '_session_db') and self._session_db and self.agent:
+            try:
+                self._session_db.end_session(self.agent.session_id, "cli_close")
+            except (Exception, KeyboardInterrupt) as e:
+                logger.debug("Could not close session in DB: %s", e)
+        # Plugin hook: on_session_end — safety net for interrupted exits.
+        # run_conversation() already fires this per-turn on normal completion,
+        # so only fire here if the agent was mid-turn (_agent_running) when
+        # the exit occurred, meaning run_conversation's hook didn't fire.
+        if self.agent and getattr(self, '_agent_running', False):
+            try:
+                from hermes_cli.plugins import invoke_hook as _invoke_hook
+                _invoke_hook(
+                    "on_session_end",
+                    session_id=self.agent.session_id,
+                    completed=False,
+                    interrupted=True,
+                    model=getattr(self.agent, 'model', None),
+                    platform=getattr(self.agent, 'platform', None) or "cli",
+                )
+            except Exception:
+                pass
+        _run_cleanup()
+        self._print_exit_summary()
+
     def run(self):
         """Run the interactive CLI loop with persistent input at bottom."""
+        if getattr(self, "headless", False):
+            try:
+                self._run_headless_loop()
+            finally:
+                self._finalize_run()
+            return
+
         # Push the entire TUI to the bottom of the terminal so the banner,
         # responses, and prompt all appear pinned to the bottom — empty
         # space stays above, not below.  This prints enough blank lines to
@@ -13324,8 +13416,7 @@ def _suppress_closed_loop_errors(loop, context):
                 "This can happen with certain Python installations (e.g. uv-managed cPython on macOS).\n"
                 "Try reinstalling Python via pyenv or Homebrew, then re-run: hermes setup"
             )
-            _run_cleanup()
-            self._print_exit_summary()
+            self._finalize_run()
             return
 
         # Run the application with patch_stdout for proper output handling
@@ -13359,58 +13450,7 @@ def _suppress_closed_loop_errors(loop, context):
             else:
                 raise
         finally:
-            self._should_exit = True
-            # Interrupt the agent immediately so its daemon thread stops making
-            # API calls and exits promptly (agent_thread is daemon, so the
-            # process will exit once the main thread finishes, but interrupting
-            # avoids wasted API calls and lets run_conversation clean up).
-            if self.agent and getattr(self, '_agent_running', False):
-                try:
-                    self.agent.interrupt()
-                except Exception:
-                    pass
-            # Shut down voice recorder (release persistent audio stream)
-            if hasattr(self, '_voice_recorder') and self._voice_recorder:
-                try:
-                    self._voice_recorder.shutdown()
-                except Exception:
-                    pass
-                self._voice_recorder = None
-            # Clean up old temp voice recordings
-            try:
-                from tools.voice_mode import cleanup_temp_recordings
-                cleanup_temp_recordings()
-            except Exception:
-                pass
-            # Unregister callbacks to avoid dangling references
-            set_sudo_password_callback(None)
-            set_approval_callback(None)
-            set_secret_capture_callback(None)
-            # Close session in SQLite
-            if hasattr(self, '_session_db') and self._session_db and self.agent:
-                try:
-                    self._session_db.end_session(self.agent.session_id, "cli_close")
-                except (Exception, KeyboardInterrupt) as e:
-                    logger.debug("Could not close session in DB: %s", e)
-            # Plugin hook: on_session_end — safety net for interrupted exits.
-            # run_conversation() already fires this per-turn on normal completion,
-            # so only fire here if the agent was mid-turn (_agent_running) when
-            # the exit occurred, meaning run_conversation's hook didn't fire.
-            if self.agent and getattr(self, '_agent_running', False):
-                try:
-                    from hermes_cli.plugins import invoke_hook as _invoke_hook
-                    _invoke_hook(
-                        "on_session_end",
-                        session_id=self.agent.session_id,
-                        completed=False,
-                        interrupted=True,
-                        model=getattr(self.agent, 'model', None),
-                        platform=getattr(self.agent, 'platform', None) or "cli",
-                    )
-                except Exception:
-                    pass
-            _run_cleanup()
-            self._print_exit_summary()
+            self._finalize_run()
 
 
 # ============================================================================
@@ -13441,6 +13481,7 @@ def main(
     pass_session_id: bool = False,
     ignore_user_config: bool = False,
     ignore_rules: bool = False,
+    headless: bool = False,
 ):
     """
     Hermes Agent CLI - Interactive AI Assistant
@@ -13560,6 +13601,7 @@ def main(
         checkpoints=checkpoints,
         pass_session_id=pass_session_id,
         ignore_rules=ignore_rules,
+        headless=headless,
     )
 
     if parsed_skills:

hermes_cli/_parser.py

@@ -225,6 +225,14 @@ def build_top_level_parser():
         default=False,
         help="With --tui: run TypeScript sources via tsx (skip dist build)",
     )
+    _inherited_flag(
+        parser,
+        "--no-gui",
+        action="store_true",
+        default=False,
+        help="Run in headless mode for non-graphical/background execution.",
+    )
+
 
     subparsers = parser.add_subparsers(dest="command", help="Command to run")
 

hermes_cli/auth.py

@@ -1388,6 +1388,7 @@ def resolve_provider(
         "go": "opencode-go", "opencode-go-sub": "opencode-go",
         "kilo": "kilocode", "kilo-code": "kilocode", "kilo-gateway": "kilocode",
         "lmstudio": "lmstudio", "lm-studio": "lmstudio", "lm_studio": "lmstudio",
+        "openai": "openrouter",
         # Local server aliases — route through the generic custom provider
         "ollama": "custom", "ollama_cloud": "ollama-cloud",
         "vllm": "custom", "llamacpp": "custom",

hermes_cli/kanban_db.py

@@ -3979,6 +3979,7 @@ def _default_spawn(
     cmd = [
         *_resolve_hermes_argv(),
         "-p", profile_arg,
+        "--no-gui",
         # Auto-load the kanban-worker skill so every dispatched worker
         # has the pattern library (good summary/metadata shapes, retry
         # diagnostics, block-reason examples) in its context, even if
@@ -3993,7 +3994,7 @@ def _default_spawn(
     # `--skills X` pair rather than a single comma-joined arg: the CLI
     # accepts both forms (action='append' + comma-split), but
     # per-name pairs are easier to read in `ps` output and avoid any
-    # quoting ambiguity if a skill name ever contains unusual chars.
+    # quoting ambiguity if a skill name ever contains unusual chars.Ы
     # Dedupe against the built-in so we don't double-load kanban-worker
     # if a task author asks for it explicitly.
     if task.skills: