klaude-code 1.2.16__py3-none-any.whl → 1.2.18__py3-none-any.whl

klaude_code/cli/config_cmd.py

@@ -12,7 +12,7 @@ from klaude_code.trace import log
 
 def list_models() -> None:
     """List all models and providers configuration"""
-    from klaude_code.config.list_model import display_models_and_providers
+    from klaude_code.cli.list_model import display_models_and_providers
     from klaude_code.ui.terminal.color import is_light_terminal_background
 
     config = load_config()

klaude_code/cli/debug.py

@@ -48,7 +48,7 @@ def open_log_file_in_editor(path: Path) -> None:
     editor = os.environ.get("EDITOR")
 
     if not editor:
-        for cmd in ["open", "xdg-open", "code", "nvim", "vim", "nano"]:
+        for cmd in ["open", "xdg-open", "code", "TextEdit", "notepad"]:
             try:
                 subprocess.run(["which", cmd], check=True, capture_output=True)
                 editor = cmd

klaude_code/cli/main.py

@@ -11,7 +11,6 @@ from klaude_code.cli.auth_cmd import register_auth_commands
 from klaude_code.cli.config_cmd import register_config_commands
 from klaude_code.cli.debug import DEBUG_FILTER_HELP, open_log_file_in_editor, resolve_debug_settings
 from klaude_code.cli.session_cmd import register_session_commands
-from klaude_code.config import load_config
 from klaude_code.session import Session, resume_select_session
 from klaude_code.trace import DebugType, prepare_debug_log_file
 
@@ -157,13 +156,8 @@ def exec_command(
     from klaude_code.config.select_model import select_model_from_config
 
     chosen_model = model
-    if select_model:
-        # Prefer the explicitly provided model as default; otherwise main model
-        config = load_config()
-        if config is None:
-            raise typer.Exit(1)
-        default_name = model or config.main_model
-        chosen_model = select_model_from_config(preferred=default_name)
+    if model or select_model:
+        chosen_model = select_model_from_config(preferred=model)
         if chosen_model is None:
             return
 
@@ -243,7 +237,7 @@ def main_callback(
         setup_terminal_title()
 
         chosen_model = model
-        if select_model:
+        if model or select_model:
             chosen_model = select_model_from_config(preferred=model)
             if chosen_model is None:
                 return

klaude_code/cli/runtime.py

@@ -10,7 +10,7 @@ from rich.text import Text
 from klaude_code import ui
 from klaude_code.command import has_interactive_command
 from klaude_code.config import Config, load_config
-from klaude_code.core.agent import Agent, DefaultModelProfileProvider, VanillaModelProfileProvider
+from klaude_code.core.agent import DefaultModelProfileProvider, VanillaModelProfileProvider
 from klaude_code.core.executor import Executor
 from klaude_code.core.manager import build_llm_clients
 from klaude_code.protocol import events, op
@@ -98,8 +98,10 @@ async def initialize_app_components(init_config: AppInitConfig) -> AppComponents
     executor_task = asyncio.create_task(executor.start())
 
     theme: str | None = config.theme
-    if theme is None:
+    if theme is None and not init_config.is_exec_mode:
         # Auto-detect theme from terminal background when config does not specify a theme.
+        # Skip detection in exec mode to avoid TTY race conditions with parent process's
+        # ESC monitor when running as a subprocess.
         detected = is_light_terminal_background()
         if detected is True:
             theme = "light"
@@ -145,8 +147,8 @@ async def initialize_session(
     await executor.submit_and_wait(op.InitAgentOperation(session_id=session_id))
     await event_queue.join()
 
-    active_session_ids = executor.context.agent_manager.active_session_ids()
-    return active_session_ids[0] if active_session_ids else session_id
+    active_session_id = executor.context.current_session_id()
+    return active_session_id or session_id
 
 
 async def cleanup_app_components(components: AppComponents) -> None:
@@ -214,16 +216,12 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
 
     # Create status provider for bottom toolbar
     def _status_provider() -> REPLStatusSnapshot:
-        agent: Agent | None = None
-        # Get the first active agent (there should only be one in interactive mode)
-        active_agents = components.executor.context.active_agents
-        if active_agents:
-            agent = next(iter(active_agents.values()), None)
-
         # Check for updates (returns None if uv not available)
         update_message = get_update_message()
 
-        return build_repl_status_snapshot(agent=agent, update_message=update_message)
+        return build_repl_status_snapshot(
+            agent=components.executor.context.current_agent, update_message=update_message
+        )
 
     # Set up input provider for interactive mode
     input_provider: ui.InputProviderABC = ui.PromptToolkitInput(status_provider=_status_provider)
@@ -261,7 +259,14 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
     try:
-        active_session_id = await initialize_session(components.executor, components.event_queue, session_id=session_id)
+        await initialize_session(components.executor, components.event_queue, session_id=session_id)
+
+        def _get_active_session_id() -> str | None:
+            """Get the current active session ID dynamically.
+
+            This is necessary because /clear command creates a new session with a different ID.
+            """
+            return components.executor.context.current_session_id()
 
         # Input
         await input_provider.start()
@@ -272,6 +277,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             elif user_input.text.strip() == "":
                 continue
             # Submit user input operation - directly use the payload from iter_inputs
+            # Use dynamic session_id lookup to handle /clear creating new sessions
+            active_session_id = _get_active_session_id()
             submission_id = await components.executor.submit(
                 op.UserInputOperation(input=user_input, session_id=active_session_id)
             )
@@ -282,7 +289,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             else:
                 # Esc monitor for long-running, interruptible operations
                 async def _on_esc_interrupt() -> None:
-                    await components.executor.submit(op.InterruptOperation(target_session_id=active_session_id))
+                    await components.executor.submit(op.InterruptOperation(target_session_id=_get_active_session_id()))
 
                 stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
                 # Wait for this specific task to complete before accepting next input

klaude_code/command/__init__.py

@@ -28,8 +28,10 @@ def ensure_commands_loaded() -> None:
 
     # Import and register commands in display order
     from .clear_cmd import ClearCommand
+    from .debug_cmd import DebugCommand
     from .diff_cmd import DiffCommand
     from .export_cmd import ExportCommand
+    from .export_online_cmd import ExportOnlineCommand
     from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
@@ -40,16 +42,18 @@ def ensure_commands_loaded() -> None:
 
     # Register in desired display order
     register(ExportCommand())
+    register(ExportOnlineCommand())
     register(RefreshTerminalCommand())
     register(ThinkingCommand())
     register(ModelCommand())
     load_prompt_commands()
-    register(ClearCommand())
     register(StatusCommand())
     register(DiffCommand())
     register(HelpCommand())
     register(ReleaseNotesCommand())
     register(TerminalSetupCommand())
+    register(DebugCommand())
+    register(ClearCommand())
 
     # Load prompt-based commands (appended after built-in commands)
 
@@ -58,8 +62,10 @@ def ensure_commands_loaded() -> None:
 def __getattr__(name: str) -> object:
     _commands_map = {
         "ClearCommand": "clear_cmd",
+        "DebugCommand": "debug_cmd",
         "DiffCommand": "diff_cmd",
         "ExportCommand": "export_cmd",
+        "ExportOnlineCommand": "export_online_cmd",
         "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",

klaude_code/command/clear_cmd.py

@@ -1,11 +1,6 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
 from klaude_code.protocol import commands
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ClearCommand(CommandABC):
     """Clear current session and start a new conversation"""
@@ -18,5 +13,5 @@ class ClearCommand(CommandABC):
     def summary(self) -> str:
         return "Clear conversation history and free up context"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         return CommandResult(actions=[InputAction.clear()])

klaude_code/command/command_abc.py

@@ -1,14 +1,37 @@
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING
+from typing import Protocol
 
 from pydantic import BaseModel
 
-from klaude_code.protocol import commands
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import commands, llm_param
 from klaude_code.protocol import events as protocol_events
+from klaude_code.session.session import Session
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
+
+class AgentProfile(Protocol):
+    """Protocol for the agent's active model profile."""
+
+    @property
+    def llm_client(self) -> LLMClientABC: ...
+
+    @property
+    def system_prompt(self) -> str | None: ...
+
+    @property
+    def tools(self) -> list[llm_param.ToolSchema]: ...
+
+
+class Agent(Protocol):
+    """Protocol for Agent objects passed to commands."""
+
+    session: Session
+
+    @property
+    def profile(self) -> AgentProfile | None: ...
+
+    def get_llm_client(self) -> LLMClientABC: ...
 
 
 class InputActionType(str, Enum):
@@ -80,8 +103,13 @@ class CommandABC(ABC):
         """Whether this command support additional parameters."""
         return False
 
+    @property
+    def placeholder(self) -> str:
+        """Placeholder text for additional parameters in help display."""
+        return "additional instructions"
+
     @abstractmethod
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         """
         Execute the command.
 

klaude_code/command/debug_cmd.py

@@ -0,0 +1,79 @@
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.trace import DebugType, get_current_log_file, is_debug_enabled, set_debug_logging
+
+
+def _format_status() -> str:
+    """Format the current debug status for display."""
+    if not is_debug_enabled():
+        return "Debug: OFF"
+
+    log_file = get_current_log_file()
+    log_path_str = str(log_file) if log_file else "(console)"
+    return f"Debug: ON\nLog file: {log_path_str}"
+
+
+def _parse_debug_filters(raw: str) -> set[DebugType] | None:
+    filters: set[DebugType] = set()
+    for chunk in raw.split(","):
+        normalized = chunk.strip().lower().replace("-", "_")
+        if not normalized:
+            continue
+        try:
+            filters.add(DebugType(normalized))
+        except ValueError as exc:
+            raise ValueError(normalized) from exc
+    return filters or None
+
+
+class DebugCommand(CommandABC):
+    """Toggle debug mode and configure debug filters."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.DEBUG
+
+    @property
+    def summary(self) -> str:
+        return "Toggle debug mode (optional: filter types)"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "filter types"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        raw = raw.strip()
+
+        # /debug (no args) - enable debug
+        if not raw:
+            set_debug_logging(True, write_to_file=True)
+            return self._message_result(agent, _format_status())
+
+        # /debug <filters> - enable with filters
+        try:
+            filters = _parse_debug_filters(raw)
+            if filters:
+                set_debug_logging(True, write_to_file=True, filters=filters)
+                filter_names = ", ".join(sorted(dt.value for dt in filters))
+                return self._message_result(agent, f"Filters: {filter_names}\n{_format_status()}")
+        except ValueError:
+            pass
+
+        return self._message_result(agent, f"Invalid filter: {raw}\nValid: {', '.join(dt.value for dt in DebugType)}")
+
+    def _message_result(self, agent: "Agent", content: str) -> CommandResult:
+        return CommandResult(
+            events=[
+                events.DeveloperMessageEvent(
+                    session_id=agent.session.id,
+                    item=model.DeveloperMessageItem(
+                        content=content,
+                        command_output=model.CommandOutput(command_name=self.name),
+                    ),
+                )
+            ]
+        )

klaude_code/command/diff_cmd.py

@@ -1,13 +1,9 @@
 import subprocess
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class DiffCommand(CommandABC):
     """Show git diff for the current repository."""
@@ -20,7 +16,7 @@ class DiffCommand(CommandABC):
     def summary(self) -> str:
         return "Show git diff"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         try:
             # Check if current directory is in a git repository
             git_check = subprocess.run(

klaude_code/command/export_cmd.py

@@ -2,15 +2,11 @@ from __future__ import annotations
 
 import subprocess
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 from klaude_code.session.export import build_export_html, get_default_export_path
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ExportCommand(CommandABC):
     """Export the current session into a standalone HTML transcript."""
@@ -25,7 +21,11 @@ class ExportCommand(CommandABC):
 
     @property
     def support_addition_params(self) -> bool:
-        return False
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "output path"
 
     @property
     def is_interactive(self) -> bool:
@@ -33,7 +33,7 @@ class ExportCommand(CommandABC):
 
     async def run(self, raw: str, agent: Agent) -> CommandResult:
         try:
-            output_path = self._resolve_output_path("", agent)
+            output_path = self._resolve_output_path(raw, agent)
             html_doc = self._build_html(agent)
             output_path.parent.mkdir(parents=True, exist_ok=True)
             output_path.write_text(html_doc, encoding="utf-8")

klaude_code/command/export_online_cmd.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import secrets
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.session.export import build_export_html
+
+
+class ExportOnlineCommand(CommandABC):
+    """Export and deploy the current session to surge.sh as a static webpage."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.EXPORT_ONLINE
+
+    @property
+    def summary(self) -> str:
+        return "Export and deploy session to surge.sh"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return False
+
+    @property
+    def is_interactive(self) -> bool:
+        return False
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        # Check if npx or surge is available
+        surge_cmd = self._get_surge_command()
+        if not surge_cmd:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="surge.sh CLI not found. Install with: npm install -g surge",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        # Check if user is logged in to surge
+        if not self._is_surge_logged_in(surge_cmd):
+            login_cmd = " ".join([*surge_cmd, "login"])
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        try:
+            html_doc = self._build_html(agent)
+            domain = self._generate_domain()
+            url = self._deploy_to_surge(surge_cmd, html_doc, domain)
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session deployed to: {url}",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event])
+        except Exception as exc:
+            import traceback
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+    def _get_surge_command(self) -> list[str] | None:
+        """Check if surge CLI is available, prefer npx if available."""
+        # Check for npx first (more common)
+        if shutil.which("npx"):
+            return ["npx", "surge"]
+        # Check for globally installed surge
+        if shutil.which("surge"):
+            return ["surge"]
+        return None
+
+    def _is_surge_logged_in(self, surge_cmd: list[str]) -> bool:
+        """Check if user is logged in to surge.sh via 'surge whoami'."""
+        try:
+            cmd = [*surge_cmd, "whoami"]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            # If logged in, whoami returns 0 and prints the email
+            # If not logged in, it returns non-zero or prints "Not Authenticated"
+            if result.returncode != 0:
+                return False
+            output = (result.stdout + result.stderr).lower()
+            if "not authenticated" in output or "not logged in" in output:
+                return False
+            return bool(result.stdout.strip())
+        except (subprocess.TimeoutExpired, OSError):
+            return False
+
+    def _generate_domain(self) -> str:
+        """Generate a random subdomain for surge.sh."""
+        random_suffix = secrets.token_hex(4)
+        return f"klaude-session-{random_suffix}.surge.sh"
+
+    def _deploy_to_surge(self, surge_cmd: list[str], html_content: str, domain: str) -> str:
+        """Deploy HTML content to surge.sh and return the URL."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            html_path = Path(tmpdir) / "index.html"
+            html_path.write_text(html_content, encoding="utf-8")
+
+            # Run surge with --domain flag
+            cmd = [*surge_cmd, tmpdir, "--domain", domain]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout or "Unknown error"
+                raise RuntimeError(f"Surge deployment failed: {error_msg}")
+
+            return f"https://{domain}"
+
+    def _build_html(self, agent: Agent) -> str:
+        profile = agent.profile
+        system_prompt = (profile.system_prompt if profile else "") or ""
+        tools = profile.tools if profile else []
+        model_name = profile.llm_client.model_name if profile else "unknown"
+        return build_export_html(agent.session, system_prompt, tools, model_name)

klaude_code/command/help_cmd.py

@@ -1,11 +1,6 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class HelpCommand(CommandABC):
     """Display help information for all available slash commands."""
@@ -18,7 +13,7 @@ class HelpCommand(CommandABC):
     def summary(self) -> str:
         return "Show help and available commands"
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         lines: list[str] = [
             """
 Usage:
@@ -39,8 +34,8 @@ Available slash commands:"""
 
         if commands:
             for cmd_name, cmd_obj in sorted(commands.items()):
-                additional_instructions = " \\[additional instructions]" if cmd_obj.support_addition_params else ""
-                lines.append(f"  [b]/{cmd_name}[/b]{additional_instructions} — {cmd_obj.summary}")
+                placeholder = f" \\[{cmd_obj.placeholder}]" if cmd_obj.support_addition_params else ""
+                lines.append(f"  [b]/{cmd_name}[/b]{placeholder} — {cmd_obj.summary}")
 
         event = events.DeveloperMessageEvent(
             session_id=agent.session.id,

klaude_code/command/model_cmd.py

@@ -1,13 +1,9 @@
 import asyncio
-from typing import TYPE_CHECKING
 
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
 from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class ModelCommand(CommandABC):
     """Display or change the model configuration."""
@@ -24,7 +20,15 @@ class ModelCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "model name"
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         selected_model = await asyncio.to_thread(select_model_from_config, preferred=raw)
 
         current_model = agent.profile.llm_client.model_name if agent.profile else None

klaude_code/command/prompt_command.py

@@ -1,15 +1,11 @@
 from importlib.resources import files
-from typing import TYPE_CHECKING
 
 import yaml
 
-from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult, InputAction
 from klaude_code.protocol import commands
 from klaude_code.trace import log_debug
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class PromptCommand(CommandABC):
     """Command that loads a prompt from a markdown file."""
@@ -59,7 +55,7 @@ class PromptCommand(CommandABC):
     def support_addition_params(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         self._ensure_loaded()
         template_content = self._content or ""
         user_input = raw.strip() or "<none>"

klaude_code/command/refresh_cmd.py

@@ -1,11 +1,6 @@
-from typing import TYPE_CHECKING
-
-from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.command.command_abc import Agent, CommandABC, CommandResult
 from klaude_code.protocol import commands, events
 
-if TYPE_CHECKING:
-    from klaude_code.core.agent import Agent
-
 
 class RefreshTerminalCommand(CommandABC):
     """Refresh terminal display"""
@@ -22,7 +17,7 @@ class RefreshTerminalCommand(CommandABC):
     def is_interactive(self) -> bool:
         return True
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         import os
 
         os.system("cls" if os.name == "nt" else "clear")